fix: add support for tracking dependencies through hybrid properties

Author: benedikt-bartscher

packages/reflex-base/src/reflex_base/vars/dep_tracking.py

@@ -185,15 +185,23 @@ def load_attr_or_method(self, instruction: dis.Instruction) -> None:
         except VarValueError:
             # If the target state is not a BaseState, we cannot track dependencies on it.
             return
+        # Look up the raw descriptor first via inspect.getattr_static so we can detect
+        # property-like descriptors (e.g. HybridProperty) that override __get__ to return
+        # something other than themselves when accessed via the class.
         try:
-            ref_obj = getattr(target_state, instruction.argval)
+            static_obj = inspect.getattr_static(target_state, instruction.argval)
         except AttributeError:
-            # Not found on this state class, maybe it is a dynamic attribute that will be picked up later.
-            ref_obj = None
+            static_obj = None
 
-        if isinstance(ref_obj, property) and not isinstance(ref_obj, ComputedVar):
+        if isinstance(static_obj, property) and not isinstance(static_obj, ComputedVar):
             # recurse into property fget functions
-            ref_obj = ref_obj.fget
+            ref_obj = static_obj.fget
+        else:
+            try:
+                ref_obj = getattr(target_state, instruction.argval)
+            except AttributeError:
+                # Not found on this state class, maybe it is a dynamic attribute that will be picked up later.
+                ref_obj = None
         if callable(ref_obj):
             # recurse into callable attributes
             self._merge_deps(

tests/integration/test_hybrid_properties.py

@@ -226,4 +226,6 @@ def test_hybrid_properties(
     )
 
     assert full_name.text == "full_name: John"
-    assert full_name_backend.text == "full_name_backend: John "
+    # Use textContent to preserve trailing whitespace (Selenium's .text strips it),
+    # since the backend f-string yields "John " (with trailing space) when last_name is empty.
+    assert full_name_backend.get_attribute("textContent") == "full_name_backend: John "

tests/units/vars/test_dep_tracking.py

@@ -428,6 +428,66 @@ def func_with_property(self):
     assert tracker.dependencies == expected_deps
 
 
+def test_hybrid_property_dependencies():
+    """Test tracking dependencies through hybrid_property access (without custom .var)."""
+    from reflex.experimental import hybrid_property
+
+    class StateWithHybridProperty(State):
+        first_name: str = "John"
+        last_name: str = "Doe"
+
+        @hybrid_property
+        def full_name(self) -> str:
+            return f"{self.first_name} {self.last_name}"
+
+        def func_using_hybrid_property(self):
+            return self.full_name
+
+    tracker = DependencyTracker(
+        StateWithHybridProperty.func_using_hybrid_property, StateWithHybridProperty
+    )
+
+    # Should recurse into the hybrid_property's fget and track its underlying deps.
+    expected_deps = {
+        StateWithHybridProperty.get_full_name(): {"first_name", "last_name"}
+    }
+    assert tracker.dependencies == expected_deps
+
+
+def test_hybrid_property_with_custom_var_dependencies():
+    """Test tracking dependencies through hybrid_property access when a custom .var is set.
+
+    The dep tracker must still recurse into the Python fget (not the frontend var function),
+    since computed vars use the backend implementation at runtime.
+    """
+    from reflex.experimental import hybrid_property
+    from reflex.vars.base import Var
+
+    class StateWithHybridPropertyVar(State):
+        last_name: str = "Doe"
+        unrelated: str = "ignored"
+
+        @hybrid_property
+        def has_last_name(self) -> str:
+            return "yes" if self.last_name else "no"
+
+        @has_last_name.var
+        def has_last_name(cls) -> Var[str]:
+            # Reference an unrelated field here to confirm the tracker uses fget, not this.
+            return cls.unrelated  # pyright: ignore[reportReturnType]
+
+        def func_using_hybrid_property(self):
+            return self.has_last_name
+
+    tracker = DependencyTracker(
+        StateWithHybridPropertyVar.func_using_hybrid_property,
+        StateWithHybridPropertyVar,
+    )
+
+    expected_deps = {StateWithHybridPropertyVar.get_full_name(): {"last_name"}}
+    assert tracker.dependencies == expected_deps
+
+
 def test_no_dependencies():
     """Test functions with no state dependencies."""