typing improvements and cleanup

Author: benedikt-bartscher

packages/reflex-base/src/reflex_base/compiler/templates.py

@@ -281,7 +281,6 @@ def context_template(
         UpdateVarsInternalState,
     )
 
-    # Compute dynamic state names that respect minification settings
     main_state_name = State.get_name()
     on_load_internal = format_event_handler(OnLoadInternalState.on_load_internal)
     update_vars_internal = format_event_handler(

packages/reflex-base/src/reflex_base/constants/compiler.py

@@ -67,18 +67,6 @@ class CompileVars(SimpleNamespace):
     CONNECT_ERROR = "connectErrors"
     # The name of the function for converting a dict to an event.
     TO_EVENT = "ReflexEvent"
-    # The name of the internal on_load event.
-    ON_LOAD_INTERNAL = "reflex___state____on_load_internal_state.on_load_internal"
-    # The name of the internal event to update generic state vars.
-    UPDATE_VARS_INTERNAL = (
-        "reflex___state____update_vars_internal_state.update_vars_internal"
-    )
-    # The name of the frontend event exception state
-    FRONTEND_EXCEPTION_STATE = "reflex___state____frontend_event_exception_state"
-    # The full name of the frontend exception state
-    FRONTEND_EXCEPTION_STATE_FULL = (
-        f"reflex___state____state.{FRONTEND_EXCEPTION_STATE}"
-    )
 
 
 class PageNames(SimpleNamespace):

packages/reflex-base/src/reflex_base/utils/format.py

@@ -6,7 +6,6 @@
 import json
 import os
 import re
-from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from reflex_base import constants
@@ -440,9 +439,7 @@ def format_props(*single_props, **key_value_props) -> list[str]:
     ] + [(f"...{LiteralVar.create(prop)!s}") for prop in single_props]
 
 
-def get_event_handler_parts(
-    handler: EventHandler | Callable[..., Any],
-) -> tuple[str, str]:
+def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
     """Get the (state, function) name pair for an event handler.
 
     Both names pass through the active
@@ -454,17 +451,9 @@ def get_event_handler_parts(
 
     Returns:
         ``(state_full_name, handler_name)`` — both resolved.
-
-    Raises:
-        TypeError: If the handler is not an EventHandler.
     """
-    from reflex_base.event import EventHandler
     from reflex_base.registry import RegistrationContext
 
-    if not isinstance(handler, EventHandler):
-        msg = f"Expected EventHandler, got {type(handler)}"
-        raise TypeError(msg)
-
     name = handler.fn.__qualname__
     if handler.state is None:
         return ("", name)
@@ -477,7 +466,7 @@ def get_event_handler_parts(
     return (state_full_name, ctx.get_handler_name(handler.state, func_name))
 
 
-def format_event_handler(handler: EventHandler | Callable[..., Any]) -> str:
+def format_event_handler(handler: EventHandler) -> str:
     """Format an event handler.
 
     Args:

reflex/minify.py

@@ -199,17 +199,23 @@ def from_disk(cls) -> MinifyNameResolver:
         """Build a resolver from the current ``minify.json`` and env vars.
 
         Bypasses the lru_cache on :func:`get_minify_config` so the snapshot
-        reflects the cwd at install time. Malformed configs become
-        ``config=None`` — the validate CLI surfaces them separately.
+        reflects the cwd at install time. A malformed config becomes
+        ``config=None`` (graceful degradation — the app still runs without
+        minification) and a warning is logged once per install so the user
+        notices.
 
         Returns:
             A configured resolver.
         """
         from reflex.environment import MinifyMode, environment
+        from reflex.utils import console
 
         try:
             config = _load_minify_config_uncached()
-        except ValueError:
+        except ValueError as e:
+            console.warn(
+                f"{MINIFY_JSON} could not be loaded: {e}; minification disabled."
+            )
             config = None
         return cls(
             config=config,
@@ -297,16 +303,20 @@ def install_minify_resolver() -> None:
 def ensure_minify_resolver_for_active_context() -> None:
     """Install a :class:`MinifyNameResolver` for the active context if needed.
 
-    Idempotent once a config-loaded resolver is in place — safe to wire into
-    hot paths (e.g. :func:`reflex.utils.prerequisites.get_app`, which can be
-    re-entered at runtime from a different cwd than the one that loaded the
-    config). Re-installs only if the current resolver has ``config=None``.
+    Idempotent in the steady state — safe to wire into hot paths
+    (e.g. :func:`reflex.utils.prerequisites.get_app`, which can be re-entered
+    at runtime from a different cwd than the one that loaded the config).
+    Re-installs only when something on disk could have changed: a config
+    appearing where there wasn't one, or a non-minify resolver in the slot.
     """
     from reflex_base.registry import RegistrationContext
 
     ctx = RegistrationContext.ensure_context()
-    if isinstance(ctx.name_resolver, MinifyNameResolver) and ctx.name_resolver.config:
-        return
+    if isinstance(ctx.name_resolver, MinifyNameResolver):
+        if ctx.name_resolver.config is not None:
+            return  # already loaded with a config — no work to do
+        if not _get_minify_json_path().exists():
+            return  # no config and none on disk; nothing changed
     ctx.set_name_resolver(MinifyNameResolver.from_disk())
 
 
@@ -493,8 +503,8 @@ def _assign_next_ids(
 ) -> dict[str, str]:
     """Assign minified ids to ``new_keys`` while skipping ``existing_ids``.
 
-    Mutates ``existing_ids`` so callers can chain assignments against the same
-    pool. Keys are sorted for deterministic output.
+    Keys are sorted for deterministic output. ``existing_ids`` is read-only —
+    a working copy is taken internally.
 
     Args:
         new_keys: Keys needing new ids.
@@ -505,13 +515,14 @@ def _assign_next_ids(
     Returns:
         Mapping from key to its newly-assigned minified id.
     """
-    next_id = 0 if reassign_deleted else max(existing_ids, default=-1) + 1
+    pool = set(existing_ids)
+    next_id = 0 if reassign_deleted else max(pool, default=-1) + 1
     out: dict[str, str] = {}
     for key in sorted(new_keys):
-        while next_id in existing_ids:
+        while next_id in pool:
             next_id += 1
         out[key] = int_to_minified_name(next_id)
-        existing_ids.add(next_id)
+        pool.add(next_id)
         next_id += 1
     return out
 
@@ -673,7 +684,7 @@ def sync_minify_config(
 
     # Assign new state IDs (unique among siblings of the same parent class).
     for parent_cls, children in parent_cls_to_new_children.items():
-        existing_ids = parent_cls_to_existing_ids.get(parent_cls, set()).copy()
+        existing_ids = parent_cls_to_existing_ids.get(parent_cls, set())
         new_states.update(_assign_next_ids(children, existing_ids, reassign_deleted))
 
     # Assign new event IDs (unique within each state).

reflex/reflex.py

@@ -1209,69 +1209,39 @@ def minify_lookup(output_json: bool, minified_path: str):
 
     Walks the state tree from the root to resolve each segment.
     """
-    from reflex.minify import get_state_full_path
-    from reflex.state import BaseState, State
+    from reflex.minify import collect_all_states, get_state_full_path
+    from reflex.state import State
 
     config = _open_minify_session()
 
-    def collect_states(
-        state_cls: type[BaseState],
-    ) -> list[type[BaseState]]:
-        """Recursively collect all states.
-
-        Args:
-            state_cls: The state class to start from.
+    # Build lookup: full_path -> minified_id (None if no entry).
+    path_to_id = {
+        get_state_full_path(s): config["states"].get(get_state_full_path(s))
+        for s in collect_all_states(State)
+    }
 
-        Returns:
-            List of all state classes in the hierarchy.
-        """
-        result = [state_cls]
-        for sub in state_cls.get_substates():
-            result.extend(collect_states(sub))
-        return result
-
-    # Build lookup: full_path -> (state_class, minified_id)
-    all_states = collect_states(State)
-    path_to_info: dict[str, tuple[type[BaseState], str | None]] = {}
-    for state_cls in all_states:
-        full_path = get_state_full_path(state_cls)
-        minified_id = config["states"].get(full_path)
-        path_to_info[full_path] = (state_cls, minified_id)
-
-    # Walk the minified path
     parts = minified_path.split(".")
     result_parts = []
     current = State
 
     for i, part in enumerate(parts):
-        # Find state whose minified ID matches 'part'
-        found = None
-        if i == 0:
-            # First segment should match root state
-            state_path = get_state_full_path(current)
-            _, state_id = path_to_info.get(state_path, (None, None))
-            if state_id == part:
-                found = current
-        else:
-            # Find among children of current
-            for child in current.get_substates():
-                child_path = get_state_full_path(child)
-                _, child_id = path_to_info.get(child_path, (None, None))
-                if child_id == part:
-                    found = child
-                    break
-
+        # Find the state whose minified id matches ``part``: the root state
+        # for the first segment, otherwise a child of the previous match.
+        candidates = [current] if i == 0 else current.get_substates()
+        found = next(
+            (c for c in candidates if path_to_id.get(get_state_full_path(c)) == part),
+            None,
+        )
         if found is None:
             console.error(
                 f"No state found for minified segment '{part}' in path '{minified_path}'"
             )
             raise SystemExit(1)
 
         state_path = get_state_full_path(found)
-        _, state_id = path_to_info.get(state_path, (None, None))
         result_parts.append({
             "minified": part,
-            "state_id": state_id,
+            "state_id": part,  # we just matched on it
             "module": found.__module__,
             "class": found.__name__,
             "full_path": state_path,