ENG-9425: fixes for extensible BaseState

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

@@ -845,7 +845,7 @@ def is_backend_base_variable(name: str, cls: type[BaseState]) -> bool:
     if name in cls.inherited_backend_vars:
         return False
 
-    from reflex_base.vars.base import is_computed_var
+    from reflex_base.vars.base import Field, Var, is_computed_var
 
     if name in cls.__dict__:
         value = cls.__dict__[name]
@@ -864,6 +864,12 @@ def is_backend_base_variable(name: str, cls: type[BaseState]) -> bool:
         ) or is_computed_var(value):
             return False
 
+        # Custom descriptors should be invoked via their __get__/__set__
+        # rather than shadowed by backend var storage. Field/Var define
+        # __get__ for type-checking but are not user descriptors.
+        if hasattr(type(value), "__get__") and not isinstance(value, (Field, Var)):
+            return False
+
     return True
 
 

reflex/state.py

@@ -304,6 +304,38 @@ def _override_base_method(fn: Callable[PARAMS, RETURN]) -> Callable[PARAMS, RETU
     return fn
 
 
+def _is_user_descriptor(value: Any) -> bool:
+    """Whether a class attribute is a user-defined descriptor.
+
+    Excludes framework-recognized callables and var types so user-defined
+    descriptors (with __get__/__set__) are surfaced for computed-var dependency
+    tracking without being shadowed by backend-var storage.
+
+    Args:
+        value: The class attribute value to check.
+
+    Returns:
+        True if the value is a custom descriptor.
+    """
+    if not hasattr(type(value), "__get__"):
+        return False
+    if isinstance(
+        value,
+        (
+            FunctionType,
+            classmethod,
+            staticmethod,
+            property,
+            functools.cached_property,
+            EventHandler,
+            Var,
+            Field,
+        ),
+    ):
+        return False
+    return not is_computed_var(value)
+
+
 all_base_state_classes: dict[str, None] = {}
 
 CLASS_VAR_NAMES = frozenset({
@@ -559,18 +591,43 @@ def __init_subclass__(cls, mixin: bool = False, **kwargs):
             for name, f in cls.get_fields().items()
             if name not in cls.get_skip_vars() and f.is_var and not name.startswith("_")
         }
+        # Surface user-defined descriptors as vars so computed vars can declare
+        # dependencies on them without routing through backend var storage.
+        descriptor_vars: dict[str, Var] = {}
+        hints = cls._get_type_hints()
+        for source_cls in (*cls._mixins(), cls):
+            for dname, dvalue in source_cls.__dict__.items():
+                if (
+                    dname in cls.base_vars
+                    or dname in descriptor_vars
+                    or dname in cls.inherited_vars
+                    or dname in cls.inherited_backend_vars
+                    or dname not in hints
+                    or not _is_user_descriptor(dvalue)
+                ):
+                    continue
+                descriptor_vars[dname] = dispatch(
+                    field_name=format.format_state_name(cls.get_full_name())
+                    + "."
+                    + dname
+                    + FIELD_MARKER,
+                    var_data=VarData.from_state(cls, dname),
+                    result_var_type=hints[dname],
+                )
         cls.computed_vars = {
             name: v._replace(merge_var_data=VarData.from_state(cls))
             for name, v in computed_vars
         }
         cls.vars = {
+            **descriptor_vars,
             **cls.inherited_vars,
             **cls.base_vars,
             **cls.computed_vars,
         }
         cls.event_handlers = {}
 
-        # Setup the base vars at the class level.
+        # Setup the base vars at the class level (skip descriptors, which have
+        # no backing pydantic field and manage their own access).
         for name, prop in cls.base_vars.items():
             cls._init_var(name, prop)
 
@@ -675,6 +732,7 @@ def _item_is_event_handler(name: str, value: Any) -> bool:
             not name.startswith("_")
             and isinstance(value, Callable)
             and not isinstance(value, EventHandler)
+            and not getattr(value, "__override_base_method__", False)
             and hasattr(value, "__code__")
         )
 

tests/units/test_state.py

@@ -4646,3 +4646,56 @@ async def test_rebind_mutable_proxy(
         assert state.data["a"] == [2, 3]
         # Object identity persists across serialization, so data["b"] is also mutated.
         assert state.data["b"] == [2, 3]
+
+
+def test_override_base_method_skips_event_handler_wrapping():
+    """A method marked with __override_base_method__ should not be wrapped as an EventHandler."""
+    from reflex.state import _override_base_method
+
+    class OverrideState(rx.State):
+        @_override_base_method
+        def custom_override(self) -> int:
+            return 42
+
+    # The marked method must remain a plain function, not an EventHandler.
+    assert not isinstance(OverrideState.__dict__["custom_override"], EventHandler)
+    assert "custom_override" not in OverrideState.event_handlers
+    assert OverrideState().custom_override() == 42
+
+
+def test_descriptor_attribute_not_in_backend_vars():
+    """A custom descriptor on a state should appear in vars/base_vars but not backend_vars."""
+
+    class _IntDescriptor:
+        def __init__(self):
+            self._values: dict[int, int] = {}
+
+        def __set_name__(self, owner, name):
+            self._name = name
+
+        def __get__(self, instance, owner):
+            if instance is None:
+                return self
+            return self._values.get(id(instance), 0)
+
+        def __set__(self, instance, value):
+            self._values[id(instance)] = value
+
+    class DescriptorState(rx.State):
+        _desc_value: int = _IntDescriptor()  # pyright: ignore[reportAssignmentType]
+
+        @rx.var
+        def doubled(self) -> int:
+            return self._desc_value * 2
+
+    # The descriptor should not be tracked as a backend var.
+    assert "_desc_value" not in DescriptorState.backend_vars
+    # But it should be visible in base_vars/vars for dependency tracking.
+    assert "_desc_value" in DescriptorState.base_vars
+    assert "_desc_value" in DescriptorState.vars
+    # Descriptor remains the class-level attribute (not overwritten by a Var).
+    assert isinstance(DescriptorState.__dict__["_desc_value"], _IntDescriptor)
+
+    # A computed var depending on the descriptor must register the dependency.
+    deps = DescriptorState._var_dependencies.get("_desc_value", set())
+    assert (DescriptorState.get_full_name(), "doubled") in deps