unique per sibling

Author: benedikt-bartscher

reflex/reflex.py

@@ -992,36 +992,42 @@ def print_state_tree(
 )
 @click.argument("minified_path")
 def state_lookup(output_json: bool, minified_path: str):
-    """Lookup a state by its minified path (e.g., 'a.bU')."""
-    from reflex.state import _minified_name_to_int, _state_id_registry
+    """Lookup a state by its minified path (e.g., 'a.bU').
+
+    Walks the state tree from the root to resolve each segment.
+    """
+    from reflex.state import State
     from reflex.utils import prerequisites
 
     # Load the user's app to register all state classes
     prerequisites.get_app()
 
-    # Parse the dotted path
-    parts = minified_path.split(".")
+    try:
+        State.get_class_substate(minified_path)
+    except ValueError:
+        msg = f"No state found for path: {minified_path}"
+        console.error(msg)
+        raise ValueError(msg) from None
 
-    # Resolve each part
+    # Build info for each ancestor segment
+    parts = minified_path.split(".")
     result_parts = []
-    for part in parts:
-        try:
-            state_id = _minified_name_to_int(part)
-        except ValueError as err:
-            console.error(f"Invalid minified name: {part}")
-            raise SystemExit(1) from err
-
-        state_cls = _state_id_registry.get(state_id)
-        if state_cls is None:
-            console.error(f"No state registered with state_id={state_id}")
-            raise SystemExit(1)
-
+    current = State
+    result_parts.append({
+        "minified": parts[0],
+        "state_id": current._state_id,
+        "module": current.__module__,
+        "class": current.__name__,
+        "full_name": current.get_full_name(),
+    })
+    for part in parts[1:]:
+        current = current.get_class_substate(part)
         result_parts.append({
             "minified": part,
-            "state_id": state_id,
-            "module": state_cls.__module__,
-            "class": state_cls.__name__,
-            "full_name": state_cls.get_full_name(),
+            "state_id": current._state_id,
+            "module": current.__module__,
+            "class": current.__name__,
+            "full_name": current.get_full_name(),
         })
 
     if output_json:
@@ -1034,31 +1040,83 @@ def state_lookup(output_json: bool, minified_path: str):
             console.log(f"{info['module']}.{info['class']}")
 
 
+def _resolve_parent_state(parent: str):
+    """Resolve a parent argument to a state class.
+
+    Accepts either a state path (minified like 'a.b' or full name) or a class
+    name (e.g., 'State', 'MySubState'). Tries path resolution first via
+    get_class_substate, then falls back to searching by class name.
+
+    Args:
+        parent: Class name or state path identifying the parent state.
+
+    Returns:
+        The resolved state class.
+
+    Raises:
+        SystemExit: If the parent cannot be resolved.
+    """
+    from reflex.state import BaseState, State
+
+    # Try as a state path (minified or full name)
+    try:
+        return State.get_class_substate(parent)
+    except ValueError:
+        pass
+
+    # Fall back to searching by class name
+    def _find_by_name(cls: type[BaseState], name: str) -> type[BaseState] | None:
+        if cls.__name__ == name:
+            return cls
+        for child in cls.class_subclasses:
+            result = _find_by_name(child, name)
+            if result is not None:
+                return result
+        return None
+
+    result = _find_by_name(State, parent)
+    if result is not None:
+        return result
+
+    console.error(f"No state found matching '{parent}'")
+    raise SystemExit(1)
+
+
 @cli.command(name="state-next-id")
 @loglevel_option
 @click.option(
     "--after-max",
     is_flag=True,
     help="Return max(state_id) + 1 instead of first gap.",
 )
-def state_next_id(after_max: bool):
-    """Print the next available state_id."""
-    from reflex.state import _state_id_registry
+@click.argument("parent")
+def state_next_id(after_max: bool, parent: str):
+    """Print the next available state_id under PARENT.
+
+    PARENT can be a class name (e.g., 'State', 'MySubState') or a
+    minified path (e.g., 'a', 'a.b'). Auto-determined from input.
+    """
     from reflex.utils import prerequisites
 
     # Load the user's app to register all state classes
     prerequisites.get_app()
 
-    if not _state_id_registry:
+    parent_cls = _resolve_parent_state(parent)
+
+    # Collect sibling state_ids under the parent
+    used_ids = {
+        child._state_id
+        for child in parent_cls.class_subclasses
+        if child._state_id is not None
+    }
+
+    if not used_ids:
         console.log("0")
         return
 
     if after_max:
-        # Return max + 1
-        next_id = max(_state_id_registry.keys()) + 1
+        next_id = max(used_ids) + 1
     else:
-        # Find first gap starting from 0
-        used_ids = set(_state_id_registry.keys())
         next_id = 0
         while next_id in used_ids:
             next_id += 1

reflex/state.py

@@ -104,8 +104,6 @@
 # For BaseState.get_var_value
 VAR_TYPE = TypeVar("VAR_TYPE")
 
-# Global registry: state_id -> state class (for duplicate detection)
-_state_id_registry: dict[int, type[BaseState]] = {}
 
 # Characters used for minified names (valid JS identifiers)
 MINIFIED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"
@@ -607,22 +605,6 @@ def __init_subclass__(
         # Store state_id as class variable (only for non-mixins)
         cls._state_id = state_id
 
-        # Validate state_id if provided (check for duplicates)
-        if state_id is not None:
-            if state_id in _state_id_registry:
-                existing_cls = _state_id_registry[state_id]
-                # Allow re-registration if it's the same class (e.g., module reload)
-                existing_key = f"{existing_cls.__module__}.{existing_cls.__name__}"
-                new_key = f"{cls.__module__}.{cls.__name__}"
-                if existing_key != new_key:
-                    msg = (
-                        f"Duplicate state_id={state_id}. Already used by "
-                        f"'{existing_cls.__module__}.{existing_cls.__name__}', "
-                        f"cannot be reused by '{cls.__module__}.{cls.__name__}'."
-                    )
-                    raise StateValueError(msg)
-            _state_id_registry[state_id] = cls
-
         # Handle locally-defined states for pickling.
         if "<locals>" in cls.__qualname__:
             cls._handle_local_def()
@@ -649,6 +631,21 @@ def __init_subclass__(
             cls.inherited_vars = parent_state.vars
             cls.inherited_backend_vars = parent_state.backend_vars
 
+            # Check for duplicate state_id among siblings.
+            if state_id is not None:
+                for sibling in parent_state.class_subclasses:
+                    if sibling._state_id is not None and sibling._state_id == state_id:
+                        # Allow re-registration of the same class (e.g., module reload)
+                        existing_key = f"{sibling.__module__}.{sibling.__name__}"
+                        new_key = f"{cls.__module__}.{cls.__name__}"
+                        if existing_key != new_key:
+                            msg = (
+                                f"Duplicate state_id={state_id} among siblings of "
+                                f"'{parent_state.__name__}': already used by "
+                                f"'{sibling.__name__}', cannot be reused by '{cls.__name__}'."
+                            )
+                            raise StateValueError(msg)
+
             # Check if another substate class with the same name has already been defined.
             if cls.get_name() in {c.get_name() for c in parent_state.class_subclasses}:
                 # This should not happen, since we have added module prefix to state names in #3214
@@ -2746,7 +2743,7 @@ def wrapper() -> Component:
 LAST_RELOADED_KEY = "reflex_last_reloaded_on_error"
 
 
-class FrontendEventExceptionState(State, state_id=1):
+class FrontendEventExceptionState(State, state_id=0):
     """Substate for handling frontend exceptions."""
 
     # If the frontend error message contains any of these strings, automatically reload the page.
@@ -2799,7 +2796,7 @@ def handle_frontend_exception(
         )
 
 
-class UpdateVarsInternalState(State, state_id=2):
+class UpdateVarsInternalState(State, state_id=1):
     """Substate for handling internal state var updates."""
 
     async def update_vars_internal(self, vars: dict[str, Any]) -> None:
@@ -2823,7 +2820,7 @@ async def update_vars_internal(self, vars: dict[str, Any]) -> None:
                 setattr(var_state, var_name, value)
 
 
-class OnLoadInternalState(State, state_id=3):
+class OnLoadInternalState(State, state_id=2):
     """Substate for handling on_load event enumeration.
 
     This is a separate substate to avoid deserializing the entire state tree for every page navigation.

tests/integration/test_minification.py

@@ -11,7 +11,7 @@
 from selenium.webdriver.common.by import By
 
 from reflex.environment import MinifyMode, environment
-from reflex.state import _int_to_minified_name, _state_id_registry
+from reflex.state import _int_to_minified_name
 from reflex.testing import AppHarness
 
 if TYPE_CHECKING:
@@ -98,14 +98,6 @@ def index() -> rx.Component:
     app.add_page(index)
 
 
-@pytest.fixture(autouse=True)
-def reset_state_registry():
-    """Reset the state_id registry before and after each test."""
-    _state_id_registry.clear()
-    yield
-    _state_id_registry.clear()
-
-
 @pytest.fixture
 def minify_disabled_app(
     app_harness_env: type[AppHarness],