reflex-dev/reflex · error · VarDependencyError

ComputedVar dependencies must be Var instances with a state

Error message

ComputedVar dependencies must be Var instances with a state and field name, got {dep!r}.

What it means

add_dependency (used to wire explicit deps for a ComputedVar) requires the dependency Var to carry both a state name and a field name in its VarData. If the Var has no var data at all, or its state/field_name is missing (e.g. a raw LiteralVar or an unlinked expression), VarDependencyError is raised. VarDependencyError subclasses RuntimeError, so it escapes 'except TypeError' handlers.

Source

Thrown at packages/reflex-base/src/reflex_base/vars/base.py:2716

                    self._static_deps.setdefault(state_name, set()).add(var_name)
                    target_state_class = objclass.get_root_state().get_class_substate(
                        state_name
                    )
                    target_state_class._var_dependencies.setdefault(
                        var_name, set()
                    ).add((
                        objclass.get_full_name(),
                        self._name,
                    ))
                    target_state_class._potentially_dirty_states.add(
                        objclass.get_full_name()
                    )
                    return
        msg = (
            "ComputedVar dependencies must be Var instances with a state and "
            f"field name, got {dep!r}."
        )
        raise VarDependencyError(msg)

    def _determine_var_type(self) -> type:
        """Get the type of the var.

        Returns:
            The type of the var.
        """
        hints = get_type_hints(self._fget)
        if "return" in hints:
            return hints["return"]
        return Any  # pyright: ignore [reportReturnType]

    @property
    def __class__(self) -> type:
        """The class of the var.

        Returns:
            The class of the var.

View on GitHub (pinned to 45b8ed5ab7)

Solutions

Reference real State attributes in deps so the Var carries state+field metadata: deps=[State.other_value] or deps=[self.other_value]
For name-based deps, pass plain strings: deps=['other_value'] (handled by the string branch, not add_dependency)
If building Vars programmatically, ensure _var_data includes state and field_name (VarData(state=..., field_name=...)) before using as a dep

Example fix

# before
@rx.var(deps=[rx.Var('counter')])  # no state/field metadata
def doubled(self) -> int:
    return self.counter * 2

# after
class State(rx.State):
    counter: int = 0

    @rx.var(deps=[State.counter])
    def doubled(self) -> int:
        return self.counter * 2
    # or deps=['counter']

Defensive patterns

Strategy: type-guard

Validate before calling

from reflex.vars import Var

def deps_with_var_data(deps):
    out = []
    for d in deps:
        if isinstance(d, str) and d:
            out.append(d)
        elif isinstance(d, Var) and (data := d._get_all_var_data()) and data.state and data.field_name:
            out.append(d)
    return out

Type guard

from reflex.vars import Var

def is_state_linked_var(dep) -> bool:
    if not isinstance(dep, Var):
        return False
    data = dep._get_all_var_data()
    return bool(data and data.state and data.field_name)

Try / catch

from reflex.vars import VarDependencyError

try:
    cv.add_dependency(state_cls, dep)
except VarDependencyError:
    # fall back to name-based dependency wiring
    state_cls._var_dependencies.setdefault(dep_name := str(dep), set()).add((state_cls.get_full_name(), cv._name))

Prevention

Always declare deps as State attributes (deps=[State.x]) or plain field-name strings
Never construct raw rx.Var(...) objects for use as dependencies
Ensure dependency Vars are not stripped of var data by expression building before use

When it happens

Trigger: Passing a literal or plain expression as a dependency: deps=[rx.Var('x')], a number/string literal Var, or a Var whose _var_data was stripped during compilation; calling ComputedVar.add_dependency(objclass, dep) where dep is not attached to any State field.

Common situations: Declaring deps with hand-constructed Vars instead of State attributes (deps=[State.counter] works; deps=[rx.Var('counter')] does not); dependency Vars created via string concatenation or operations that drop var data; compiler/state-machinery edge cases after refactoring State hierarchies.

Related errors

AI-assisted analysis of reflex-dev/reflex@45b8ed5ab7 (2026-08-28). Data as JSON: /api/errors/2b924ba79459680a. Report an issue: GitHub.