fix the test

reflex/app.py

@@ -1151,7 +1151,7 @@ class App(MiddlewareMixin, LifespanMixin):
                 for dep in dep_set:
                     if dep not in state_cls.vars and dep not in state_cls.backend_vars:
                         raise exceptions.VarDependencyError(
-                            f"ComputedVar {var._js_expr} on state {state.__name__} has an invalid dependency {state_name}.{dep}"
+                            f"ComputedVar {var._name} on state {state.__name__} has an invalid dependency {state_name}.{dep}"
                         )
 
         for substate in state.class_subclasses:

reflex/state.py

@@ -440,14 +440,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return f"{type(self).__name__}({self.dict()})"
 
     @classmethod
-    def _get_computed_vars(cls) -> list[ComputedVar]:
+    def _get_computed_vars(cls) -> list[tuple[str, ComputedVar]]:
         """Helper function to get all computed vars of a instance.
 
         Returns:
             A list of computed vars.
         """
         return [
-            v
+            (name, v)
             for mixin in [*cls._mixins(), cls]
             for name, v in mixin.__dict__.items()
             if is_computed_var(v) and name not in cls.inherited_vars
@@ -554,8 +554,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if f.name not in cls.get_skip_vars()
         }
         cls.computed_vars = {
-            v._js_expr: v._replace(merge_var_data=VarData.from_state(cls))
-            for v in computed_vars
+            name: v._replace(merge_var_data=VarData.from_state(cls))
+            for name, v in computed_vars
         }
         cls.vars = {
             **cls.inherited_vars,
@@ -844,8 +844,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         Raises:
             ComputedVarShadowsBaseVarsError: When a computed var shadows a base var.
         """
-        for computed_var_ in cls._get_computed_vars():
-            if computed_var_._js_expr in cls.__annotations__:
+        for name, computed_var_ in cls._get_computed_vars():
+            if name in cls.__annotations__:
                 raise ComputedVarShadowsBaseVarsError(
                     f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
                 )
@@ -1943,7 +1943,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         )
 
         subdelta: dict[str, Any] = {
-            prop: self.get_value(prop)
+            prop + "_rx_state_": self.get_value(prop)
             for prop in delta_vars
             if not types.is_backend_base_variable(prop, type(self))
         }

reflex/vars/base.py

@@ -2087,6 +2087,8 @@ class ComputedVar(Var[RETURN_TYPE]):
         default_factory=lambda: lambda _: None
     )  # pyright: ignore [reportAssignmentType]
 
+    _name: str = dataclasses.field(default="")
+
     def __init__(
         self,
         fget: Callable[[BASE_STATE], RETURN_TYPE],
@@ -2127,7 +2129,7 @@ class ComputedVar(Var[RETURN_TYPE]):
             self,
             _js_expr=kwargs.pop("_js_expr"),
             _var_type=kwargs.pop("_var_type"),
-            _var_data=kwargs.pop("_var_data", None),
+            _var_data=kwargs.pop("_var_data", VarData(field_name=fget.__name__)),
         )
 
         if kwargs:
@@ -2139,6 +2141,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         object.__setattr__(self, "_backend", backend)
         object.__setattr__(self, "_initial_value", initial_value)
         object.__setattr__(self, "_cache", cache)
+        object.__setattr__(self, "_name", fget.__name__)
 
         if isinstance(interval, int):
             interval = datetime.timedelta(seconds=interval)
@@ -2381,7 +2384,7 @@ class ComputedVar(Var[RETURN_TYPE]):
 
             return dispatch(
                 field_name,
-                var_data=VarData.from_state(state_where_defined, self._js_expr),
+                var_data=VarData.from_state(state_where_defined, self._name),
                 result_var_type=self._var_type,
                 existing_var=self,
             )
@@ -2493,7 +2496,7 @@ class ComputedVar(Var[RETURN_TYPE]):
                     objclass.get_root_state().get_class_substate(
                         state_name
                     )._var_dependencies.setdefault(var_name, set()).add(
-                        (objclass.get_full_name(), self._js_expr)
+                        (objclass.get_full_name(), self._name)
                     )
                     return
         raise VarDependencyError(

tests/units/components/core/test_cond.py

@@ -139,7 +139,8 @@ def test_cond_computed_var():
 
     state_name = format_state_name(CondStateComputed.get_full_name())
     assert (
-        str(comp) == f"(true ? {state_name}.computed_int : {state_name}.computed_str)"
+        str(comp)
+        == f"(true ? {state_name}.computed_int_rx_state_ : {state_name}.computed_str_rx_state_)"
     )
 
     assert comp._var_type == int | str

tests/units/test_app.py

@@ -502,7 +502,7 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             payload={"value": 50},
         )
     ):
-        assert result.delta == {test_state.get_name(): {"int_val": 50}}
+        assert result.delta == {test_state.get_name(): {"int_val_rx_state_": 50}}
 
 
 @pytest.mark.asyncio
@@ -513,11 +513,11 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             [
                 (
                     "make_friend",
-                    {"plain_friends": ["Tommy", "another-fd"]},
+                    {"plain_friends_rx_state_": ["Tommy", "another-fd"]},
                 ),
                 (
                     "change_first_friend",
-                    {"plain_friends": ["Jenny", "another-fd"]},
+                    {"plain_friends_rx_state_": ["Jenny", "another-fd"]},
                 ),
             ],
             id="append then __setitem__",
@@ -526,11 +526,11 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             [
                 (
                     "unfriend_first_friend",
-                    {"plain_friends": []},
+                    {"plain_friends_rx_state_": []},
                 ),
                 (
                     "make_friend",
-                    {"plain_friends": ["another-fd"]},
+                    {"plain_friends_rx_state_": ["another-fd"]},
                 ),
             ],
             id="delitem then append",
@@ -539,19 +539,19 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             [
                 (
                     "make_friends_with_colleagues",
-                    {"plain_friends": ["Tommy", "Peter", "Jimmy"]},
+                    {"plain_friends_rx_state_": ["Tommy", "Peter", "Jimmy"]},
                 ),
                 (
                     "remove_tommy",
-                    {"plain_friends": ["Peter", "Jimmy"]},
+                    {"plain_friends_rx_state_": ["Peter", "Jimmy"]},
                 ),
                 (
                     "remove_last_friend",
-                    {"plain_friends": ["Peter"]},
+                    {"plain_friends_rx_state_": ["Peter"]},
                 ),
                 (
                     "unfriend_all_friends",
-                    {"plain_friends": []},
+                    {"plain_friends_rx_state_": []},
                 ),
             ],
             id="extend, remove, pop, clear",
@@ -560,15 +560,20 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             [
                 (
                     "add_jimmy_to_second_group",
-                    {"friends_in_nested_list": [["Tommy"], ["Jenny", "Jimmy"]]},
+                    {
+                        "friends_in_nested_list_rx_state_": [
+                            ["Tommy"],
+                            ["Jenny", "Jimmy"],
+                        ]
+                    },
                 ),
                 (
                     "remove_first_person_from_first_group",
-                    {"friends_in_nested_list": [[], ["Jenny", "Jimmy"]]},
+                    {"friends_in_nested_list_rx_state_": [[], ["Jenny", "Jimmy"]]},
                 ),
                 (
                     "remove_first_group",
-                    {"friends_in_nested_list": [["Jenny", "Jimmy"]]},
+                    {"friends_in_nested_list_rx_state_": [["Jenny", "Jimmy"]]},
                 ),
             ],
             id="nested list",
@@ -577,15 +582,15 @@ async def test_dynamic_var_event(test_state: type[ATestState], token: str):
             [
                 (
                     "add_jimmy_to_tommy_friends",
-                    {"friends_in_dict": {"Tommy": ["Jenny", "Jimmy"]}},
+                    {"friends_in_dict_rx_state_": {"Tommy": ["Jenny", "Jimmy"]}},
                 ),
                 (
                     "remove_jenny_from_tommy",
-                    {"friends_in_dict": {"Tommy": ["Jimmy"]}},
+                    {"friends_in_dict_rx_state_": {"Tommy": ["Jimmy"]}},
                 ),
                 (
                     "tommy_has_no_fds",
-                    {"friends_in_dict": {"Tommy": []}},
+                    {"friends_in_dict_rx_state_": {"Tommy": []}},
                 ),
             ],
             id="list in dict",
@@ -627,15 +632,15 @@ async def test_list_mutation_detection__plain_list(
             [
                 (
                     "add_age",
-                    {"details": {"name": "Tommy", "age": 20}},
+                    {"details_rx_state_": {"name": "Tommy", "age": 20}},
                 ),
                 (
                     "change_name",
-                    {"details": {"name": "Jenny", "age": 20}},
+                    {"details_rx_state_": {"name": "Jenny", "age": 20}},
                 ),
                 (
                     "remove_last_detail",
-                    {"details": {"name": "Jenny"}},
+                    {"details_rx_state_": {"name": "Jenny"}},
                 ),
             ],
             id="update then __setitem__",
@@ -644,11 +649,11 @@ async def test_list_mutation_detection__plain_list(
             [
                 (
                     "clear_details",
-                    {"details": {}},
+                    {"details_rx_state_": {}},
                 ),
                 (
                     "add_age",
-                    {"details": {"age": 20}},
+                    {"details_rx_state_": {"age": 20}},
                 ),
             ],
             id="delitem then update",
@@ -657,15 +662,15 @@ async def test_list_mutation_detection__plain_list(
             [
                 (
                     "add_age",
-                    {"details": {"name": "Tommy", "age": 20}},
+                    {"details_rx_state_": {"name": "Tommy", "age": 20}},
                 ),
                 (
                     "remove_name",
-                    {"details": {"age": 20}},
+                    {"details_rx_state_": {"age": 20}},
                 ),
                 (
                     "pop_out_age",
-                    {"details": {}},
+                    {"details_rx_state_": {}},
                 ),
             ],
             id="add, remove, pop",
@@ -674,12 +679,12 @@ async def test_list_mutation_detection__plain_list(
             [
                 (
                     "remove_home_address",
-                    {"address": [{}, {"work": "work address"}]},
+                    {"address_rx_state_": [{}, {"work": "work address"}]},
                 ),
                 (
                     "add_street_to_home_address",
                     {
-                        "address": [
+                        "address_rx_state_": [
                             {"street": "street address"},
                             {"work": "work address"},
                         ]
@@ -693,7 +698,7 @@ async def test_list_mutation_detection__plain_list(
                 (
                     "change_friend_name",
                     {
-                        "friend_in_nested_dict": {
+                        "friend_in_nested_dict_rx_state_": {
                             "name": "Nikhil",
                             "friend": {"name": "Tommy"},
                         }
@@ -702,7 +707,7 @@ async def test_list_mutation_detection__plain_list(
                 (
                     "add_friend_age",
                     {
-                        "friend_in_nested_dict": {
+                        "friend_in_nested_dict_rx_state_": {
                             "name": "Nikhil",
                             "friend": {"name": "Tommy", "age": 30},
                         }
@@ -710,7 +715,7 @@ async def test_list_mutation_detection__plain_list(
                 ),
                 (
                     "remove_friend",
-                    {"friend_in_nested_dict": {"name": "Nikhil"}},
+                    {"friend_in_nested_dict_rx_state_": {"name": "Nikhil"}},
                 ),
             ],
             id="nested dict",
@@ -753,7 +758,7 @@ async def test_dict_mutation_detection__plain_list(
             FileUploadState,
             {
                 FileUploadState.get_full_name(): {
-                    "img_list": ["image1.jpg", "image2.jpg"]
+                    "img_list_rx_state_": ["image1.jpg", "image2.jpg"]
                 }
             },
         ),
@@ -761,7 +766,7 @@ async def test_dict_mutation_detection__plain_list(
             ChildFileUploadState,
             {
                 ChildFileUploadState.get_full_name(): {
-                    "img_list": ["image1.jpg", "image2.jpg"]
+                    "img_list_rx_state_": ["image1.jpg", "image2.jpg"]
                 }
             },
         ),
@@ -769,7 +774,7 @@ async def test_dict_mutation_detection__plain_list(
             GrandChildFileUploadState,
             {
                 GrandChildFileUploadState.get_full_name(): {
-                    "img_list": ["image1.jpg", "image2.jpg"]
+                    "img_list_rx_state_": ["image1.jpg", "image2.jpg"]
                 }
             },
         ),
@@ -840,7 +845,7 @@ async def test_upload_file(tmp_path, state, delta, token: str, mocker):
 
     current_state = await app.state_manager.get_state(_substate_key(token, state))
     state_dict = current_state.dict()[state.get_full_name()]
-    assert state_dict["img_list"] == [
+    assert state_dict["img_list_rx_state_"] == [
         "image1.jpg",
         "image2.jpg",
     ]
@@ -1116,10 +1121,10 @@ async def test_dynamic_route_var_route_change_completed_on_load(
         assert update == StateUpdate(
             delta={
                 state.get_name(): {
-                    arg_name: exp_val,
-                    f"comp_{arg_name}": exp_val,
-                    constants.CompileVars.IS_HYDRATED: False,
-                    "router": exp_router,
+                    arg_name + "_rx_state_": exp_val,
+                    f"comp_{arg_name}_rx_state_": exp_val,
+                    constants.CompileVars.IS_HYDRATED + "_rx_state_": False,
+                    "router_rx_state_": exp_router,
                 }
             },
             events=[
@@ -1159,7 +1164,7 @@ async def test_dynamic_route_var_route_change_completed_on_load(
         assert on_load_update == StateUpdate(
             delta={
                 state.get_name(): {
-                    "loaded": exp_index + 1,
+                    "loaded_rx_state_": exp_index + 1,
                 },
             },
             events=[],
@@ -1180,7 +1185,7 @@ async def test_dynamic_route_var_route_change_completed_on_load(
         assert on_set_is_hydrated_update == StateUpdate(
             delta={
                 state.get_name(): {
-                    "is_hydrated": True,
+                    "is_hydrated_rx_state_": True,
                 },
             },
             events=[],
@@ -1201,7 +1206,7 @@ async def test_dynamic_route_var_route_change_completed_on_load(
         assert update == StateUpdate(
             delta={
                 state.get_name(): {
-                    "counter": exp_index + 1,
+                    "counter_rx_state_": exp_index + 1,
                 }
             },
             events=[],

tests/units/test_state.py

@@ -311,8 +311,8 @@ def test_computed_class_var(test_state):
     """
     cls = type(test_state)
     vars = [(prop._js_expr, prop._var_type) for prop in cls.computed_vars.values()]
-    assert ("sum", float) in vars
-    assert ("upper", str) in vars
+    assert ("sum_rx_state_", float) in vars
+    assert ("upper_rx_state_", str) in vars
 
 
 def test_class_vars(test_state):
@@ -405,10 +405,12 @@ def test_dict(test_state: TestState):
     }
     test_state_dict = test_state.dict()
     assert set(test_state_dict) == substates
-    assert set(test_state_dict[test_state.get_name()]) == set(test_state.vars)
-    assert set(test_state.dict(include_computed=False)[test_state.get_name()]) == set(
-        test_state.base_vars
-    )
+    assert set(test_state_dict[test_state.get_name()]) == {
+        var + "_rx_state_" for var in test_state.vars
+    }
+    assert set(test_state.dict(include_computed=False)[test_state.get_name()]) == {
+        var + "_rx_state_" for var in test_state.base_vars
+    }
 
 
 def test_default_setters(test_state):
@@ -794,8 +796,8 @@ async def test_process_event_simple(test_state):
 
         # The delta should contain the changes, including computed vars.
         assert update.delta == {
-            TestState.get_full_name(): {"num1": 69, "sum": 72.14},
-            GrandchildState3.get_full_name(): {"computed": ""},
+            TestState.get_full_name(): {"num1_rx_state_": 69, "sum_rx_state_": 72.14},
+            GrandchildState3.get_full_name(): {"computed_rx_state_": ""},
         }
         assert update.events == []
 
@@ -822,8 +824,11 @@ async def test_process_event_substate(test_state, child_state, grandchild_state)
         assert child_state.count == 24
         assert update.delta == {
             # TestState.get_full_name(): {"sum": 3.14, "upper": ""},
-            ChildState.get_full_name(): {"value": "HI", "count": 24},
-            GrandchildState3.get_full_name(): {"computed": ""},
+            ChildState.get_full_name(): {
+                "value_rx_state_": "HI",
+                "count_rx_state_": 24,
+            },
+            GrandchildState3.get_full_name(): {"computed_rx_state_": ""},
         }
         test_state._clean()
 
@@ -838,8 +843,8 @@ async def test_process_event_substate(test_state, child_state, grandchild_state)
         assert grandchild_state.value2 == "new"
         assert update.delta == {
             # TestState.get_full_name(): {"sum": 3.14, "upper": ""},
-            GrandchildState.get_full_name(): {"value2": "new"},
-            GrandchildState3.get_full_name(): {"computed": ""},
+            GrandchildState.get_full_name(): {"value2_rx_state_": "new"},
+            GrandchildState3.get_full_name(): {"computed_rx_state_": ""},
         }
 
 
@@ -863,7 +868,7 @@ async def test_process_event_generator():
         else:
             assert gen_state.value == count
             assert update.delta == {
-                GenState.get_full_name(): {"value": count},
+                GenState.get_full_name(): {"value_rx_state_": count},
             }
             assert not update.final
 
@@ -1062,14 +1067,14 @@ def test_interdependent_state_initial_dict() -> None:
     s = InterdependentState()
     state_name = s.get_name()
     d = s.dict(initial=True)[state_name]
-    d.pop("router")
+    d.pop("router_rx_state_")
     assert d == {
-        "x": 0,
-        "v1": 0,
-        "v1x2": 0,
-        "v2x2": 2,
-        "v1x2x2": 0,
-        "v3x2": 2,
+        "x_rx_state_": 0,
+        "v1_rx_state_": 0,
+        "v1x2_rx_state_": 0,
+        "v2x2_rx_state_": 2,
+        "v1x2x2_rx_state_": 0,
+        "v3x2_rx_state_": 2,
     }
 
 
@@ -1083,7 +1088,7 @@ def test_not_dirty_computed_var_from_var(
     """
     interdependent_state.x = 5
     assert interdependent_state.get_delta() == {
-        interdependent_state.get_full_name(): {"x": 5},
+        interdependent_state.get_full_name(): {"x_rx_state_": 5},
     }
 
 
@@ -1098,7 +1103,11 @@ def test_dirty_computed_var_from_var(interdependent_state: InterdependentState)
     """
     interdependent_state.v1 = 1
     assert interdependent_state.get_delta() == {
-        interdependent_state.get_full_name(): {"v1": 1, "v1x2": 2, "v1x2x2": 4},
+        interdependent_state.get_full_name(): {
+            "v1_rx_state_": 1,
+            "v1x2_rx_state_": 2,
+            "v1x2x2_rx_state_": 4,
+        },
     }
 
 
@@ -1114,7 +1123,10 @@ def test_dirty_computed_var_from_backend_var(
     # assert InterdependentState._v3._backend is True
     interdependent_state._v2 = 2
     assert interdependent_state.get_delta() == {
-        interdependent_state.get_full_name(): {"v2x2": 4, "v3x2": 4},
+        interdependent_state.get_full_name(): {
+            "v2x2_rx_state_": 4,
+            "v3x2_rx_state_": 4,
+        },
     }
 
 
@@ -1252,9 +1264,9 @@ def test_computed_var_cached():
             return self.v
 
     cs = ComputedState()
-    assert cs.dict()[cs.get_full_name()]["v"] == 0
+    assert cs.dict()[cs.get_full_name()]["v_rx_state_"] == 0
     assert comp_v_calls == 1
-    assert cs.dict()[cs.get_full_name()]["comp_v"] == 0
+    assert cs.dict()[cs.get_full_name()]["comp_v_rx_state_"] == 0
     assert comp_v_calls == 1
     assert cs.comp_v == 0
     assert comp_v_calls == 1
@@ -1284,23 +1296,36 @@ def test_computed_var_cached_depends_on_non_cached():
 
     cs = ComputedState()
     assert cs.dirty_vars == set()
-    assert cs.get_delta() == {cs.get_name(): {"no_cache_v": 0, "dep_v": 0}}
+    assert cs.get_delta() == {
+        cs.get_name(): {"no_cache_v_rx_state_": 0, "dep_v_rx_state_": 0}
+    }
     cs._clean()
     assert cs.dirty_vars == set()
-    assert cs.get_delta() == {cs.get_name(): {"no_cache_v": 0, "dep_v": 0}}
+    assert cs.get_delta() == {
+        cs.get_name(): {"no_cache_v_rx_state_": 0, "dep_v_rx_state_": 0}
+    }
     cs._clean()
     assert cs.dirty_vars == set()
     cs.v = 1
     assert cs.dirty_vars == {"v", "comp_v", "dep_v", "no_cache_v"}
     assert cs.get_delta() == {
-        cs.get_name(): {"v": 1, "no_cache_v": 1, "dep_v": 1, "comp_v": 1}
+        cs.get_name(): {
+            "v_rx_state_": 1,
+            "no_cache_v_rx_state_": 1,
+            "dep_v_rx_state_": 1,
+            "comp_v_rx_state_": 1,
+        }
     }
     cs._clean()
     assert cs.dirty_vars == set()
-    assert cs.get_delta() == {cs.get_name(): {"no_cache_v": 1, "dep_v": 1}}
+    assert cs.get_delta() == {
+        cs.get_name(): {"no_cache_v_rx_state_": 1, "dep_v_rx_state_": 1}
+    }
     cs._clean()
     assert cs.dirty_vars == set()
-    assert cs.get_delta() == {cs.get_name(): {"no_cache_v": 1, "dep_v": 1}}
+    assert cs.get_delta() == {
+        cs.get_name(): {"no_cache_v_rx_state_": 1, "dep_v_rx_state_": 1}
+    }
     cs._clean()
     assert cs.dirty_vars == set()
 
@@ -1329,22 +1354,22 @@ def test_computed_var_depends_on_parent_non_cached():
 
     dict1 = json.loads(json_dumps(ps.dict()))
     assert dict1[ps.get_full_name()] == {
-        "no_cache_v": 1,
-        "router": formatted_router,
+        "no_cache_v_rx_state_": 1,
+        "router_rx_state_": formatted_router,
     }
-    assert dict1[cs.get_full_name()] == {"dep_v": 2}
+    assert dict1[cs.get_full_name()] == {"dep_v_rx_state_": 2}
     dict2 = json.loads(json_dumps(ps.dict()))
     assert dict2[ps.get_full_name()] == {
-        "no_cache_v": 3,
-        "router": formatted_router,
+        "no_cache_v_rx_state_": 3,
+        "router_rx_state_": formatted_router,
     }
-    assert dict2[cs.get_full_name()] == {"dep_v": 4}
+    assert dict2[cs.get_full_name()] == {"dep_v_rx_state_": 4}
     dict3 = json.loads(json_dumps(ps.dict()))
     assert dict3[ps.get_full_name()] == {
-        "no_cache_v": 5,
-        "router": formatted_router,
+        "no_cache_v_rx_state_": 5,
+        "router_rx_state_": formatted_router,
     }
-    assert dict3[cs.get_full_name()] == {"dep_v": 6}
+    assert dict3[cs.get_full_name()] == {"dep_v_rx_state_": 6}
     assert counter == 6
 
 
@@ -2035,10 +2060,10 @@ async def test_state_proxy(grandchild_state: GrandchildState, mock_app: rx.App):
     assert mcall.args[1] == StateUpdate(
         delta={
             grandchild_state.get_full_name(): {
-                "value2": "42",
+                "value2_rx_state_": "42",
             },
             GrandchildState3.get_full_name(): {
-                "computed": "",
+                "computed_rx_state_": "",
             },
         }
     )
@@ -2197,11 +2222,11 @@ async def test_background_task_no_block(mock_app: rx.App, token: str):
         assert update == StateUpdate(
             delta={
                 BackgroundTaskState.get_full_name(): {
-                    "order": [
+                    "order_rx_state_": [
                         "background_task:start",
                         "other",
                     ],
-                    "computed_order": [
+                    "computed_order_rx_state_": [
                         "background_task:start",
                         "other",
                     ],
@@ -2233,14 +2258,16 @@ async def test_background_task_no_block(mock_app: rx.App, token: str):
 
     first_ws_message = emit_mock.mock_calls[0].args[1]  # pyright: ignore [reportFunctionMemberAccess]
     assert (
-        first_ws_message.delta[BackgroundTaskState.get_full_name()].pop("router")
+        first_ws_message.delta[BackgroundTaskState.get_full_name()].pop(
+            "router_rx_state_"
+        )
         is not None
     )
     assert first_ws_message == StateUpdate(
         delta={
             BackgroundTaskState.get_full_name(): {
-                "order": ["background_task:start"],
-                "computed_order": ["background_task:start"],
+                "order_rx_state_": ["background_task:start"],
+                "computed_order_rx_state_": ["background_task:start"],
             }
         },
         events=[],
@@ -2250,7 +2277,7 @@ async def test_background_task_no_block(mock_app: rx.App, token: str):
         assert call.args[1] == StateUpdate(
             delta={
                 BackgroundTaskState.get_full_name(): {
-                    "computed_order": ["background_task:start"],
+                    "computed_order_rx_state_": ["background_task:start"],
                 }
             },
             events=[],
@@ -2259,9 +2286,9 @@ async def test_background_task_no_block(mock_app: rx.App, token: str):
     assert emit_mock.mock_calls[-2].args[1] == StateUpdate(  # pyright: ignore [reportFunctionMemberAccess]
         delta={
             BackgroundTaskState.get_full_name(): {
-                "order": exp_order,
-                "computed_order": exp_order,
-                "dict_list": {},
+                "order_rx_state_": exp_order,
+                "computed_order_rx_state_": exp_order,
+                "dict_list_rx_state_": {},
             }
         },
         events=[],
@@ -2270,7 +2297,7 @@ async def test_background_task_no_block(mock_app: rx.App, token: str):
     assert emit_mock.mock_calls[-1].args[1] == StateUpdate(  # pyright: ignore [reportFunctionMemberAccess]
         delta={
             BackgroundTaskState.get_full_name(): {
-                "computed_order": exp_order,
+                "computed_order_rx_state_": exp_order,
             },
         },
         events=[],
@@ -2651,13 +2678,15 @@ def test_json_dumps_with_mutables():
         items: list[Foo] = [Foo()]
 
     dict_val = MutableContainsBase().dict()
-    assert isinstance(dict_val[MutableContainsBase.get_full_name()]["items"][0], Foo)
+    assert isinstance(
+        dict_val[MutableContainsBase.get_full_name()]["items_rx_state_"][0], Foo
+    )
     val = json_dumps(dict_val)
     f_items = '[{"tags": ["123", "456"]}]'
     f_formatted_router = str(formatted_router).replace("'", '"')
     assert (
         val
-        == f'{{"{MutableContainsBase.get_full_name()}": {{"items": {f_items}, "router": {f_formatted_router}}}}}'
+        == f'{{"{MutableContainsBase.get_full_name()}": {{"items_rx_state_": {f_items}, "router_rx_state_": {f_formatted_router}}}}}'
     )
 
 
@@ -2823,7 +2852,9 @@ def exp_is_hydrated(state: BaseState, is_hydrated: bool = True) -> dict[str, Any
     Returns:
         dict similar to that returned by `State.get_delta` with IS_HYDRATED: is_hydrated
     """
-    return {state.get_full_name(): {CompileVars.IS_HYDRATED: is_hydrated}}
+    return {
+        state.get_full_name(): {CompileVars.IS_HYDRATED + "_rx_state_": is_hydrated}
+    }
 
 
 class OnLoadState(State):
@@ -2910,13 +2941,13 @@ async def test_preprocess(app_module_mock, token, test_state, expected, mocker):
         assert isinstance(update, StateUpdate)
         updates.append(update)
     assert len(updates) == 1
-    assert updates[0].delta[State.get_name()].pop("router") is not None
+    assert updates[0].delta[State.get_name()].pop("router_rx_state_") is not None
     assert updates[0].delta == exp_is_hydrated(state, False)
 
     events = updates[0].events
     assert len(events) == 2
     async for update in state._process(events[0]):
-        assert update.delta == {test_state.get_full_name(): {"num": 1}}
+        assert update.delta == {test_state.get_full_name(): {"num_rx_state_": 1}}
     async for update in state._process(events[1]):
         assert update.delta == exp_is_hydrated(state)
 
@@ -2958,15 +2989,15 @@ async def test_preprocess_multiple_load_events(app_module_mock, token, mocker):
         assert isinstance(update, StateUpdate)
         updates.append(update)
     assert len(updates) == 1
-    assert updates[0].delta[State.get_name()].pop("router") is not None
+    assert updates[0].delta[State.get_name()].pop("router_rx_state_") is not None
     assert updates[0].delta == exp_is_hydrated(state, False)
 
     events = updates[0].events
     assert len(events) == 3
     async for update in state._process(events[0]):
-        assert update.delta == {OnLoadState.get_full_name(): {"num": 1}}
+        assert update.delta == {OnLoadState.get_full_name(): {"num_rx_state_": 1}}
     async for update in state._process(events[1]):
-        assert update.delta == {OnLoadState.get_full_name(): {"num": 2}}
+        assert update.delta == {OnLoadState.get_full_name(): {"num_rx_state_": 2}}
     async for update in state._process(events[2]):
         assert update.delta == exp_is_hydrated(state)
 
@@ -3042,10 +3073,10 @@ async def test_get_state(mock_app: rx.App, token: str):
 
     assert test_state.get_delta() == {
         GrandchildState.get_full_name(): {
-            "value2": "set_value",
+            "value2_rx_state_": "set_value",
         },
         GrandchildState3.get_full_name(): {
-            "computed": "",
+            "computed_rx_state_": "",
         },
     }
 
@@ -3079,13 +3110,13 @@ async def test_get_state(mock_app: rx.App, token: str):
 
     assert new_test_state.get_delta() == {
         ChildState2.get_full_name(): {
-            "value": "set_c2_value",
+            "value_rx_state_": "set_c2_value",
         },
         GrandchildState2.get_full_name(): {
-            "cached": "set_c2_value",
+            "cached_rx_state_": "set_c2_value",
         },
         GrandchildState3.get_full_name(): {
-            "computed": "",
+            "computed_rx_state_": "",
         },
     }
 
@@ -3718,8 +3749,8 @@ def test_get_value():
 
     assert state.dict() == {
         state.get_full_name(): {
-            "foo": "FOO",
-            "bar": "BAR",
+            "foo_rx_state_": "FOO",
+            "bar_rx_state_": "BAR",
         }
     }
     assert state.get_delta() == {}
@@ -3728,13 +3759,13 @@ def test_get_value():
 
     assert state.dict() == {
         state.get_full_name(): {
-            "foo": "FOO",
-            "bar": "foo",
+            "foo_rx_state_": "FOO",
+            "bar_rx_state_": "foo",
         }
     }
     assert state.get_delta() == {
         state.get_full_name(): {
-            "bar": "foo",
+            "bar_rx_state_": "foo",
         }
     }
 
@@ -3855,7 +3886,7 @@ async def test_upcast_event_handler_arg(handler, payload):
     """
     state = UpcastState()
     async for update in state._process_event(handler, state, payload):
-        assert update.delta == {UpcastState.get_full_name(): {"passed": True}}
+        assert update.delta == {UpcastState.get_full_name(): {"passed_rx_state_": True}}
 
 
 @pytest.mark.asyncio

tests/units/test_var.py

@@ -818,28 +818,28 @@ def test_computed_var_with_annotation_error(request, fixture):
     [
         (
             "StateWithInitialComputedVar",
-            "var_with_initial_value",
+            "var_with_initial_value_rx_state_",
             "Initial value",
             "Runtime value",
             False,
         ),
         (
             "ChildWithInitialComputedVar",
-            "var_with_initial_value_child",
+            "var_with_initial_value_child_rx_state_",
             "Initial value",
             "Runtime value",
             False,
         ),
         (
             "StateWithRuntimeOnlyVar",
-            "var_raises_at_runtime",
+            "var_raises_at_runtime_rx_state_",
             None,
             None,
             True,
         ),
         (
             "ChildWithRuntimeOnlyVar",
-            "var_raises_at_runtime_child",
+            "var_raises_at_runtime_child_rx_state_",
             "Initial value",
             None,
             True,
@@ -1789,7 +1789,7 @@ def cv_fget(state: BaseState) -> int:
     [
         (["a"], {None: {"a"}}),
         (["b"], {None: {"b"}}),
-        ([ComputedVar(fget=cv_fget)], {None: {"cv_fget"}}),
+        ([ComputedVar(fget=cv_fget)], {None: {"cv_fget_rx_state_"}}),
     ],
 )
 def test_computed_var_deps(deps: list[str | Var], expected: set[str]):

tests/units/utils/test_format.py

@@ -586,44 +586,44 @@ formatted_router = {
             TestState(_reflex_internal_init=True).dict(),  # pyright: ignore [reportCallIssue]
             {
                 TestState.get_full_name(): {
-                    "array": [1, 2, 3.14],
-                    "complex": {
+                    "array_rx_state_": [1, 2, 3.14],
+                    "complex_rx_state_": {
                         1: {"prop1": 42, "prop2": "hello"},
                         2: {"prop1": 42, "prop2": "hello"},
                     },
-                    "dt": "1989-11-09 18:53:00+01:00",
-                    "fig": serialize_figure(go.Figure()),
-                    "key": "",
-                    "map_key": "a",
-                    "mapping": {"a": [1, 2, 3], "b": [4, 5, 6]},
-                    "num1": 0,
-                    "num2": 3.14,
-                    "obj": {"prop1": 42, "prop2": "hello"},
-                    "sum": 3.14,
-                    "upper": "",
-                    "router": formatted_router,
-                    "asynctest": 0,
+                    "dt_rx_state_": "1989-11-09 18:53:00+01:00",
+                    "fig_rx_state_": serialize_figure(go.Figure()),
+                    "key_rx_state_": "",
+                    "map_key_rx_state_": "a",
+                    "mapping_rx_state_": {"a": [1, 2, 3], "b": [4, 5, 6]},
+                    "num1_rx_state_": 0,
+                    "num2_rx_state_": 3.14,
+                    "obj_rx_state_": {"prop1": 42, "prop2": "hello"},
+                    "sum_rx_state_": 3.14,
+                    "upper_rx_state_": "",
+                    "router_rx_state_": formatted_router,
+                    "asynctest_rx_state_": 0,
                 },
                 ChildState.get_full_name(): {
-                    "count": 23,
-                    "value": "",
+                    "count_rx_state_": 23,
+                    "value_rx_state_": "",
                 },
-                ChildState2.get_full_name(): {"value": ""},
-                ChildState3.get_full_name(): {"value": ""},
-                GrandchildState.get_full_name(): {"value2": ""},
-                GrandchildState2.get_full_name(): {"cached": ""},
-                GrandchildState3.get_full_name(): {"computed": ""},
+                ChildState2.get_full_name(): {"value_rx_state_": ""},
+                ChildState3.get_full_name(): {"value_rx_state_": ""},
+                GrandchildState.get_full_name(): {"value2_rx_state_": ""},
+                GrandchildState2.get_full_name(): {"cached_rx_state_": ""},
+                GrandchildState3.get_full_name(): {"computed_rx_state_": ""},
             },
         ),
         (
             DateTimeState(_reflex_internal_init=True).dict(),  # pyright: ignore [reportCallIssue]
             {
                 DateTimeState.get_full_name(): {
-                    "d": "1989-11-09",
-                    "dt": "1989-11-09 18:53:00+01:00",
-                    "t": "18:53:00+01:00",
-                    "td": "11 days, 0:11:00",
-                    "router": formatted_router,
+                    "d_rx_state_": "1989-11-09",
+                    "dt_rx_state_": "1989-11-09 18:53:00+01:00",
+                    "t_rx_state_": "18:53:00+01:00",
+                    "td_rx_state_": "11 days, 0:11:00",
+                    "router_rx_state_": formatted_router,
                 },
             },
         ),