Implement ReactPyConfig(TypedDict)

Author: Archmonger

docs/source/about/changelog.rst

@@ -29,6 +29,7 @@ Unreleased
 - :pull:`1256` - Change ``set_state`` comparison method to check equality with ``==`` more consistently.
 - :pull:`1257` - Add support for rendering ``@component`` children within ``vdom_to_html``.
 - :pull:`1113` - Renamed the ``use_location`` hook's ``search`` attribute to ``query_string``.
+- :pull:`1113` - Renamed ``reatpy.config.REACTPY_DEBUG_MODE`` to ``reactpy.config.REACTPY_DEBUG``.
 
 **Removed**
 

pyproject.toml

@@ -74,7 +74,6 @@ commands = [
 artifacts = []
 
 [project.optional-dependencies]
-# TODO: Nuke backends from the optional deps
 all = ["reactpy[jinja,uvicorn,testing]"]
 jinja = ["jinja2-simple-tags", "jinja2 >=3"]
 uvicorn = ["uvicorn[standard]"]

src/reactpy/asgi/middleware.py

@@ -13,13 +13,14 @@
 import orjson
 from asgiref.compatibility import guarantee_single_callable
 from servestatic import ServeStaticASGI
+from typing_extensions import Unpack
 
-from reactpy.asgi.utils import check_path, import_components
-from reactpy.config import REACTPY_WEB_MODULES_DIR
+from reactpy import config
+from reactpy.asgi.utils import check_path, import_components, process_settings
 from reactpy.core.hooks import ConnectionContext
 from reactpy.core.layout import Layout
 from reactpy.core.serve import serve_layout
-from reactpy.types import Connection, Location, RootComponentConstructor
+from reactpy.types import Connection, Location, ReactPyConfig, RootComponentConstructor
 
 _logger = logging.getLogger(__name__)
 
@@ -34,14 +35,15 @@ def __init__(
         self,
         app: Callable[..., Coroutine],
         root_components: Iterable[str],
-        *,
-        # TODO: Add a setting attribute to this class. Or maybe just put a shit ton of kwargs here. Or add a **kwargs that resolves to a TypedDict?
-        path_prefix: str = "/reactpy/",
-        web_modules_dir: Path | None = None,
+        **settings: Unpack[ReactPyConfig],
     ) -> None:
-        """Configure the ASGI app. Anything initialized in this method will be shared across all future requests."""
+        """Configure the ASGI app. Anything initialized in this method will be shared across all future requests.
+        TODO: Add types in docstring"""
+        # Process global settings
+        process_settings(settings)
+
         # URL path attributes
-        self.path_prefix = path_prefix
+        self.path_prefix = config.REACTPY_PATH_PREFIX.current
         self.dispatcher_path = self.path_prefix
         self.web_modules_path = f"{self.path_prefix}modules/"
         self.static_path = f"{self.path_prefix}static/"
@@ -56,20 +58,22 @@ def __init__(
         self.root_components = import_components(root_components)
 
         # Directory attributes
-        self.web_modules_dir = web_modules_dir or REACTPY_WEB_MODULES_DIR.current
+        self.web_modules_dir = config.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)
 
         # 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)
+        reason = check_path(self.path_prefix)
         if reason:
             raise ValueError(f"Invalid `path_prefix`. {reason}")
+        if not self.web_modules_dir.exists():
+            raise ValueError(
+                f"Web modules directory {self.web_modules_dir} does not exist."
+            )
 
     async def __call__(
         self,
@@ -127,12 +131,12 @@ async def __call__(
                     self.run_dispatcher(scope, receive, send, recv_queue)
                 )
 
-            if event["type"] == "websocket.disconnect":
+            elif event["type"] == "websocket.disconnect":
                 if dispatcher:
                     dispatcher.cancel()
                 break
 
-            if event["type"] == "websocket.receive":
+            elif event["type"] == "websocket.receive":
                 queue_put_func = recv_queue.put(orjson.loads(event["text"]))
                 await queue_put_func
 
@@ -143,8 +147,9 @@ async def run_dispatcher(
         send: Callable[..., Coroutine],
         recv_queue: asyncio.Queue,
     ) -> None:
-        # Get the component from the URL.
+        """Asyncio background task that renders and transmits layout updates of ReactPy components."""
         try:
+            # Determine component to serve by analyzing the URL and/or class parameters.
             if self.parent.multiple_root_components:
                 url_match = re.match(self.parent.dispatcher_pattern, scope["path"])
                 if not url_match:
@@ -160,42 +165,38 @@ async def run_dispatcher(
             else:
                 raise RuntimeError("No root component provided.")
 
-            # TODO: Get HTTP URL from `http_pathname` and `http_query_string`
-            parsed_url = urllib.parse.urlparse(scope["path"])
-            pathname = parsed_url.path
-            query_string = f"?{parsed_url.query}" if parsed_url.query else ""
+            # Create a connection object by analyzing the websocket's query string.
+            ws_query_string = urllib.parse.parse_qs(
+                scope["query_string"].decode(), strict_parsing=True
+            )
+            connection = Connection(
+                scope=scope,
+                location=Location(
+                    pathname=ws_query_string.get("http_pathname", [""])[0],
+                    query_string=ws_query_string.get("http_search", [""])[0],
+                ),
+                carrier=self,
+            )
 
+            # Start the ReactPy component rendering loop
             await serve_layout(
-                Layout(  # type: ignore
-                    ConnectionContext(
-                        component(),
-                        value=Connection(
-                            scope=scope,
-                            location=Location(
-                                pathname=pathname, query_string=query_string
-                            ),
-                            carrier={
-                                "scope": scope,
-                                "send": send,
-                                "receive": receive,
-                            },
-                        ),
-                    )
-                ),
-                self.send_json(send),
+                Layout(ConnectionContext(component(), value=connection)),  # type: ignore
+                self._send_json(send),
                 recv_queue.get,
             )
+
+        # Manually log exceptions since this function is running in a separate asyncio task.
         except Exception as error:
             await asyncio.to_thread(_logger.error, f"{error}\n{traceback.format_exc()}")
 
     @staticmethod
-    def send_json(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:
+        async def _send(value: Any) -> None:
             await send({"type": "websocket.send", "text": orjson.dumps(value).decode()})
 
-        return _send_json
+        return _send
 
 
 @dataclass
@@ -210,14 +211,6 @@ async def __call__(
         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,
@@ -240,13 +233,6 @@ async def __call__(
         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,

src/reactpy/asgi/standalone.py

@@ -8,6 +8,8 @@
 from pathlib import Path
 from typing import Any, Callable
 
+from typing_extensions import Unpack
+
 from reactpy import html
 from reactpy.asgi.middleware import ReactPyMiddleware
 from reactpy.asgi.utils import (
@@ -16,8 +18,7 @@
     replace_many,
     vdom_head_to_html,
 )
-from reactpy.core.types import VdomDict
-from reactpy.types import RootComponentConstructor
+from reactpy.types import ReactPyConfig, RootComponentConstructor, VdomDict
 
 _logger = getLogger(__name__)
 
@@ -29,18 +30,13 @@ def __init__(
         self,
         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",
+        **settings: Unpack[ReactPyConfig],
     ) -> None:
-        super().__init__(
-            app=ReactPyApp(self),
-            root_components=[],
-            path_prefix=path_prefix,
-            web_modules_dir=web_modules_dir,
-        )
+        """TODO: Add docstring"""
+        super().__init__(app=ReactPyApp(self), root_components=[], **settings)
         self.root_component = root_component
         self.extra_headers = http_headers or {}
         self.dispatcher_pattern = re.compile(f"^{self.dispatcher_path}?")
@@ -123,7 +119,7 @@ def match_dispatch_path(self, scope: dict) -> bool:
         """Method override to remove `dotted_path` from the dispatcher URL."""
         return str(scope["path"]) == self.parent.dispatcher_path
 
-    def process_index_html(self):
+    def process_index_html(self) -> None:
         """Process the index.html and store the results in memory."""
         with open(self._index_html_path, encoding="utf-8") as file_handle:
             cached_index_html = file_handle.read()

src/reactpy/asgi/utils.py

@@ -5,7 +5,8 @@
 from importlib import import_module
 from typing import Any, Callable
 
-from reactpy.core.types import VdomDict
+from reactpy._option import Option
+from reactpy.types import ReactPyConfig, VdomDict
 from reactpy.utils import vdom_to_html
 
 logger = logging.getLogger(__name__)
@@ -93,3 +94,16 @@ async def http_response(
 
     await send(start_msg)
     await send(body_msg)
+
+
+def process_settings(settings: ReactPyConfig):
+    """Process the settings and return the final configuration."""
+    from reactpy import config
+
+    for setting in settings:
+        config_name = f"REACTPY_{setting.upper()}"
+        config_object: Option | None = getattr(config, config_name, None)
+        if config_object:
+            config_object.set_current(settings[setting])
+        else:
+            raise ValueError(f"Unknown ReactPy setting {setting!r}.")

src/reactpy/config.py

@@ -33,9 +33,7 @@ def boolean(value: str | bool | int) -> bool:
         )
 
 
-REACTPY_DEBUG_MODE = Option(
-    "REACTPY_DEBUG_MODE", default=False, validator=boolean, mutable=True
-)
+REACTPY_DEBUG = Option("REACTPY_DEBUG", default=False, validator=boolean, mutable=True)
 """Get extra logs and validation checks at the cost of performance.
 
 This will enable the following:
@@ -44,13 +42,13 @@ def boolean(value: str | bool | int) -> bool:
 - :data:`REACTPY_CHECK_JSON_ATTRS`
 """
 
-REACTPY_CHECK_VDOM_SPEC = Option("REACTPY_CHECK_VDOM_SPEC", parent=REACTPY_DEBUG_MODE)
+REACTPY_CHECK_VDOM_SPEC = Option("REACTPY_CHECK_VDOM_SPEC", parent=REACTPY_DEBUG)
 """Checks which ensure VDOM is rendered to spec
 
 For more info on the VDOM spec, see here: :ref:`VDOM JSON Schema`
 """
 
-REACTPY_CHECK_JSON_ATTRS = Option("REACTPY_CHECK_JSON_ATTRS", parent=REACTPY_DEBUG_MODE)
+REACTPY_CHECK_JSON_ATTRS = Option("REACTPY_CHECK_JSON_ATTRS", parent=REACTPY_DEBUG)
 """Checks that all VDOM attributes are JSON serializable
 
 The VDOM spec is not able to enforce this on its own since attributes could anything.
@@ -73,8 +71,8 @@ def boolean(value: str | bool | int) -> bool:
 set of publicly available APIs for working with the client.
 """
 
-REACTPY_TESTING_DEFAULT_TIMEOUT = Option(
-    "REACTPY_TESTING_DEFAULT_TIMEOUT",
+REACTPY_TESTS_DEFAULT_TIMEOUT = Option(
+    "REACTPY_TESTS_DEFAULT_TIMEOUT",
     10.0,
     mutable=False,
     validator=float,
@@ -88,3 +86,43 @@ def boolean(value: str | bool | int) -> bool:
     validator=boolean,
 )
 """Whether to render components asynchronously. This is currently an experimental feature."""
+
+REACTPY_RECONNECT_INTERVAL = Option(
+    "REACTPY_RECONNECT_INTERVAL",
+    default=750,
+    mutable=True,
+    validator=int,
+)
+"""The interval in milliseconds between reconnection attempts for the websocket server"""
+
+REACTPY_RECONNECT_MAX_INTERVAL = Option(
+    "REACTPY_RECONNECT_MAX_INTERVAL",
+    default=60000,
+    mutable=True,
+    validator=int,
+)
+"""The maximum interval in milliseconds between reconnection attempts for the websocket server"""
+
+REACTPY_RECONNECT_MAX_RETRIES = Option(
+    "REACTPY_RECONNECT_MAX_RETRIES",
+    default=150,
+    mutable=True,
+    validator=int,
+)
+"""The maximum number of reconnection attempts for the websocket server"""
+
+REACTPY_RECONNECT_BACKOFF_MULTIPLIER = Option(
+    "REACTPY_RECONNECT_BACKOFF_MULTIPLIER",
+    default=1.25,
+    mutable=True,
+    validator=float,
+)
+"""The multiplier for exponential backoff between reconnection attempts for the websocket server"""
+
+REACTPY_PATH_PREFIX = Option(
+    "REACTPY_PATH_PREFIX",
+    default="/reactpy/",
+    mutable=True,
+    validator=str,
+)
+"""The prefix for all ReactPy routes"""

src/reactpy/core/hooks.py

@@ -18,7 +18,7 @@
 
 from typing_extensions import TypeAlias
 
-from reactpy.config import REACTPY_DEBUG_MODE
+from reactpy.config import REACTPY_DEBUG
 from reactpy.core._life_cycle_hook import current_hook
 from reactpy.core.types import Context, Key, State, VdomDict
 from reactpy.types import Connection, Location
@@ -204,7 +204,7 @@ def use_debug_value(
     memo_func = message if callable(message) else lambda: message
     new = use_memo(memo_func, dependencies)
 
-    if REACTPY_DEBUG_MODE.current and old.current != new:
+    if REACTPY_DEBUG.current and old.current != new:
         old.current = new
         logger.debug(f"{current_hook().component} {new}")
 

src/reactpy/core/layout.py

@@ -32,7 +32,7 @@
 from reactpy.config import (
     REACTPY_ASYNC_RENDERING,
     REACTPY_CHECK_VDOM_SPEC,
-    REACTPY_DEBUG_MODE,
+    REACTPY_DEBUG,
 )
 from reactpy.core._life_cycle_hook import LifeCycleHook
 from reactpy.core.types import (
@@ -202,9 +202,7 @@ async def _render_component(
             new_state.model.current = {
                 "tagName": "",
                 "error": (
-                    f"{type(error).__name__}: {error}"
-                    if REACTPY_DEBUG_MODE.current
-                    else ""
+                    f"{type(error).__name__}: {error}" if REACTPY_DEBUG.current else ""
                 ),
             }
         finally: