wip

Author: benedikt-bartscher

packages/reflex-base/src/reflex_base/event/__init__.py

@@ -470,6 +470,26 @@ def __call__(self, *args: Any, **kwargs: Any) -> "EventSpec":
         )
 
 
+if TYPE_CHECKING:
+
+    def typing_event(fn: Callable[..., Any]) -> EventHandler:
+        """Mark ``fn`` so pyright sees it as the ``EventHandler`` that
+        ``BaseState.__init_subclass__`` will rewrite it into. No-op at runtime.
+
+        Args:
+            fn: The method to mark.
+
+        Returns:
+            ``fn`` typed as :class:`EventHandler`.
+        """
+        ...
+
+else:
+
+    def typing_event(fn: Callable[..., Any]) -> Callable[..., Any]:  # noqa: D103
+        return fn
+
+
 @dataclasses.dataclass(
     init=True,
     frozen=True,
@@ -2833,6 +2853,7 @@ def BaseState(self) -> "type[BaseState]":  # noqa: N802
 
 event = EventNamespace
 event.event = event  # pyright: ignore[reportAttributeAccessIssue]
+event.typing_event = staticmethod(typing_event)  # pyright: ignore[reportAttributeAccessIssue]
 _this = sys.modules[__name__]
 event.__path__ = _this.__path__  # pyright: ignore[reportAttributeAccessIssue]
 event.__spec__ = _this.__spec__  # pyright: ignore[reportAttributeAccessIssue]

reflex/minify.py

@@ -108,18 +108,8 @@ def get_minify_config() -> MinifyConfig | None:
     return _load_minify_config_uncached()
 
 
-def is_minify_enabled() -> bool:
-    """Whether either state or event minification is enabled.
-
-    Returns:
-        ``True`` if either ``REFLEX_MINIFY_STATES`` or ``REFLEX_MINIFY_EVENTS``
-        is on and a config exists.
-    """
-    return is_state_minify_enabled() or is_event_minify_enabled()
-
-
 @functools.cache
-def _is_mode_enabled(env_var_name: str) -> bool:
+def is_mode_enabled(env_var_name: str) -> bool:
     """Whether the given ``REFLEX_MINIFY_*`` env var is on and a config exists.
 
     Args:
@@ -135,22 +125,16 @@ def _is_mode_enabled(env_var_name: str) -> bool:
     return env_var.get() == MinifyMode.ENABLED and get_minify_config() is not None
 
 
-def is_state_minify_enabled() -> bool:
-    """Whether state-id minification is enabled.
-
-    Returns:
-        ``True`` if ``REFLEX_MINIFY_STATES=enabled`` and ``minify.json`` exists.
-    """
-    return _is_mode_enabled("REFLEX_MINIFY_STATES")
-
-
-def is_event_minify_enabled() -> bool:
-    """Whether event-id minification is enabled.
+def is_minify_enabled() -> bool:
+    """Whether either state or event minification is enabled.
 
     Returns:
-        ``True`` if ``REFLEX_MINIFY_EVENTS=enabled`` and ``minify.json`` exists.
+        ``True`` when ``REFLEX_MINIFY_STATES`` or ``REFLEX_MINIFY_EVENTS`` is
+        on and ``minify.json`` exists.
     """
-    return _is_mode_enabled("REFLEX_MINIFY_EVENTS")
+    return is_mode_enabled("REFLEX_MINIFY_STATES") or is_mode_enabled(
+        "REFLEX_MINIFY_EVENTS"
+    )
 
 
 def save_minify_config(config: MinifyConfig) -> None:
@@ -316,7 +300,7 @@ def clear_config_cache() -> None:
     ``REFLEX_MINIFY_*`` env vars at runtime.
     """
     get_minify_config.cache_clear()
-    _is_mode_enabled.cache_clear()
+    is_mode_enabled.cache_clear()
     install_minify_resolver()
 
 

reflex/state.py

@@ -36,6 +36,7 @@
     EventHandler,
     EventSpec,
     call_script,
+    typing_event,
 )
 from reflex_base.utils.exceptions import (
     ComputedVarShadowsBaseVarsError,
@@ -2268,12 +2269,6 @@ def wrapper() -> Component:
 class FrontendEventExceptionState(State):
     """Substate for handling frontend exceptions."""
 
-    # ``__init_subclass__`` replaces the method below with an ``EventHandler``
-    # instance on the class. Splitting via ``TYPE_CHECKING`` lets callers
-    # (e.g. ``format_event_handler``) see the post-rewrite type.
-    if TYPE_CHECKING:
-        handle_frontend_exception: EventHandler
-
     # If the frontend error message contains any of these strings, automatically reload the page.
     auto_reload_on_errors: ClassVar[list[re.Pattern]] = [
         re.compile(  # Chrome/Edge
@@ -2291,68 +2286,62 @@ class FrontendEventExceptionState(State):
         ),
     ]
 
-    if not TYPE_CHECKING:
+    @typing_event
+    def handle_frontend_exception(
+        self, info: str, component_stack: str
+    ) -> Iterator[EventSpec]:
+        """Handle frontend exceptions.
 
-        @event
-        def handle_frontend_exception(
-            self, info: str, component_stack: str
-        ) -> Iterator[EventSpec]:
-            """Handle frontend exceptions.
-
-            If a frontend exception handler is provided, it will be called.
-            Otherwise, the default frontend exception handler will be called.
-
-            Args:
-                info: The exception information.
-                component_stack: The stack trace of the component where the exception occurred.
-
-            Yields:
-                Optional auto-reload event for certain errors outside cooldown period.
-            """
-            # Handle automatic reload for certain errors.
-            if type(self).auto_reload_on_errors and any(
-                error.search(info) for error in type(self).auto_reload_on_errors
-            ):
-                yield call_script(
-                    f"const last_reload = parseInt(window.sessionStorage.getItem('{LAST_RELOADED_KEY}')) || 0;"
-                    f"if (Date.now() - last_reload > {environment.REFLEX_AUTO_RELOAD_COOLDOWN_TIME_MS.get()})"
-                    "{"
-                    f"window.sessionStorage.setItem('{LAST_RELOADED_KEY}', Date.now().toString());"
-                    "window.location.reload();"
-                    "}"
-                )
-            prerequisites.get_and_validate_app().app.frontend_exception_handler(
-                Exception(info)
+        If a frontend exception handler is provided, it will be called.
+        Otherwise, the default frontend exception handler will be called.
+
+        Args:
+            info: The exception information.
+            component_stack: The stack trace of the component where the exception occurred.
+
+        Yields:
+            Optional auto-reload event for certain errors outside cooldown period.
+        """
+        # Handle automatic reload for certain errors.
+        if type(self).auto_reload_on_errors and any(
+            error.search(info) for error in type(self).auto_reload_on_errors
+        ):
+            yield call_script(
+                f"const last_reload = parseInt(window.sessionStorage.getItem('{LAST_RELOADED_KEY}')) || 0;"
+                f"if (Date.now() - last_reload > {environment.REFLEX_AUTO_RELOAD_COOLDOWN_TIME_MS.get()})"
+                "{"
+                f"window.sessionStorage.setItem('{LAST_RELOADED_KEY}', Date.now().toString());"
+                "window.location.reload();"
+                "}"
             )
+        prerequisites.get_and_validate_app().app.frontend_exception_handler(
+            Exception(info)
+        )
 
 
 class UpdateVarsInternalState(State):
     """Substate for handling internal state var updates."""
 
-    # See ``FrontendEventExceptionState`` for why this is split.
-    if TYPE_CHECKING:
-        update_vars_internal: EventHandler
-    else:
+    @typing_event
+    async def update_vars_internal(self, vars: dict[str, Any]) -> None:
+        """Apply updates to fully qualified state vars.
 
-        async def update_vars_internal(self, vars: dict[str, Any]) -> None:
-            """Apply updates to fully qualified state vars.
+        The keys in `vars` should be in the form of `{state.get_full_name()}.{var_name}`,
+        and each value will be set on the appropriate substate instance.
 
-            The keys in `vars` should be in the form of `{state.get_full_name()}.{var_name}`,
-            and each value will be set on the appropriate substate instance.
+        This function is primarily used to apply cookie and local storage
+        updates from the frontend to the appropriate substate.
 
-            This function is primarily used to apply cookie and local storage
-            updates from the frontend to the appropriate substate.
-
-            Args:
-                vars: The fully qualified vars and values to update.
-            """
-            for var, value in vars.items():
-                state_name, _, var_name = var.rpartition(".")
-                var_name = var_name.removesuffix(FIELD_MARKER)
-                var_state_cls = State.get_class_substate(state_name)
-                if var_state_cls._is_client_storage(var_name):
-                    var_state = await self.get_state(var_state_cls)
-                    setattr(var_state, var_name, value)
+        Args:
+            vars: The fully qualified vars and values to update.
+        """
+        for var, value in vars.items():
+            state_name, _, var_name = var.rpartition(".")
+            var_name = var_name.removesuffix(FIELD_MARKER)
+            var_state_cls = State.get_class_substate(state_name)
+            if var_state_cls._is_client_storage(var_name):
+                var_state = await self.get_state(var_state_cls)
+                setattr(var_state, var_name, value)
 
 
 class OnLoadInternalState(State):
@@ -2361,47 +2350,42 @@ class OnLoadInternalState(State):
     This is a separate substate to avoid deserializing the entire state tree for every page navigation.
     """
 
-    # See ``FrontendEventExceptionState`` for why this is split.
-    if TYPE_CHECKING:
-        on_load_internal: EventHandler
-
     # Cannot properly annotate this as `App` due to circular import issues.
     _app_ref: ClassVar[Any] = None
 
-    if not TYPE_CHECKING:
+    @typing_event
+    def on_load_internal(self) -> list[Event | EventSpec | event.EventCallback] | None:
+        """Queue on_load handlers for the current page.
+
+        Returns:
+            The list of events to queue for on load handling.
+
+        Raises:
+            TypeError: If the app reference is not of type App.
+        """
+        from reflex.app import App
 
-        def on_load_internal(
-            self,
-        ) -> list[Event | EventSpec | event.EventCallback] | None:
-            """Queue on_load handlers for the current page.
-
-            Returns:
-                The list of events to queue for on load handling.
-
-            Raises:
-                TypeError: If the app reference is not of type App.
-            """
-            from reflex.app import App
-
-            app = type(self)._app_ref or prerequisites.get_and_validate_app().app
-            if not isinstance(app, App):
-                msg = f"Expected app to be of type {App.__name__}, got {type(app).__name__}."
-                raise TypeError(msg)
-            # Cache the app reference for subsequent calls.
-            if type(self)._app_ref is None:
-                type(self)._app_ref = app
-            load_events = app.get_load_events(self.router.url.path)
-            if not load_events:
-                self.is_hydrated = True
-                return None  # Fast path for navigation with no on_load events defined.
-            self.is_hydrated = False
-            return [
-                *Event.from_event_type(
-                    load_events,
-                    router_data=self.router_data,
-                ),
-                State.set_is_hydrated(True),
-            ]
+        app = type(self)._app_ref or prerequisites.get_and_validate_app().app
+        if not isinstance(app, App):
+            msg = (
+                f"Expected app to be of type {App.__name__}, got {type(app).__name__}."
+            )
+            raise TypeError(msg)
+        # Cache the app reference for subsequent calls.
+        if type(self)._app_ref is None:
+            type(self)._app_ref = app
+        load_events = app.get_load_events(self.router.url.path)
+        if not load_events:
+            self.is_hydrated = True
+            return None  # Fast path for navigation with no on_load events defined.
+        self.is_hydrated = False
+        return [
+            *Event.from_event_type(
+                load_events,
+                router_data=self.router_data,
+            ),
+            State.set_is_hydrated(True),
+        ]
 
 
 class ComponentState(State, mixin=True):