Skip to content
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
An object or boolean Var rendered as a child now brings along the hooks and imports of its `to_string()`, so a Var type with its own string form no longer breaks the page.
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@

from __future__ import annotations

import functools
import logging
from collections.abc import Iterator, Sequence
from typing import Any
Expand All @@ -11,7 +12,6 @@
from reflex_base.components.tags.tagless import Tagless
from reflex_base.environment import PerformanceMode, environment
from reflex_base.utils.decorator import once
from reflex_base.utils.imports import ParsedImportDict
from reflex_base.vars import BooleanVar, ObjectVar, Var
from reflex_base.vars.base import GLOBAL_CACHE, VarData
from reflex_base.vars.sequence import LiteralStringVar
Expand Down Expand Up @@ -86,9 +86,8 @@ def _get_all_hooks_internal(self) -> dict[str, VarData | None]:
The hooks for the component.
"""
hooks = super()._get_all_hooks_internal()
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
hooks |= component._get_all_hooks_internal()
for component in self._contents_components():
hooks |= component._get_all_hooks_internal()
return hooks

def _get_all_hooks(self) -> dict[str, VarData | None]:
Expand All @@ -98,51 +97,10 @@ def _get_all_hooks(self) -> dict[str, VarData | None]:
The hooks for the component.
"""
hooks = super()._get_all_hooks()
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
hooks |= component._get_all_hooks()
for component in self._contents_components():
hooks |= component._get_all_hooks()
return hooks

def _get_all_imports(self, collapse: bool = False) -> ParsedImportDict:
"""Include the imports for the component.

Args:
collapse: Whether to collapse the imports.

Returns:
The imports for the component.
"""
imports = super()._get_all_imports(collapse=collapse)
if isinstance(self.contents, Var):
var_data = self.contents._get_all_var_data()
if var_data:
imports |= {k: list(v) for k, v in var_data.imports}
return imports

def _get_all_dynamic_imports(self) -> set[str]:
"""Get dynamic imports for the component.

Returns:
The dynamic imports.
"""
dynamic_imports = super()._get_all_dynamic_imports()
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
dynamic_imports |= component._get_all_dynamic_imports()
return dynamic_imports

def _get_all_custom_code(self) -> dict[str, None]:
"""Get custom code for the component.

Returns:
The custom code.
"""
custom_code = super()._get_all_custom_code()
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
custom_code |= component._get_all_custom_code()
return custom_code

def _get_all_app_wrap_components(
self, *, ignore_ids: set[int] | None = None
) -> dict[tuple[int, str], Component]:
Expand All @@ -158,37 +116,70 @@ def _get_all_app_wrap_components(
app_wrap_components = super()._get_all_app_wrap_components(
ignore_ids=ignore_ids
)
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
component_id = id(component)
if isinstance(component, Component) and component_id not in ignore_ids:
ignore_ids.add(component_id)
app_wrap_components |= component._get_all_app_wrap_components(
ignore_ids=ignore_ids
)
for component in self._contents_components():
component_id = id(component)
if isinstance(component, Component) and component_id not in ignore_ids:
ignore_ids.add(component_id)
app_wrap_components |= component._get_all_app_wrap_components(
ignore_ids=ignore_ids
)
return app_wrap_components

def _get_all_refs(self) -> dict[str, None]:
"""Get the refs for the children of the component.
@functools.cached_property

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2: This cached property becomes stale when Bare.contents is reassigned. _contents_vars() rebuilds the rendered var for a new contents identity, but imports, refs, custom code, dynamic imports, and compiler traversal still use the old component list; avoid caching this derived property or invalidate it whenever contents changes.

Prompt for AI agents
Check if this issue is valid — if so, understand the root cause and fix it. When an issue isn't valid or won't be fixed in this PR, reply in its thread with the reason and then resolve the thread. At packages/reflex-components-core/src/reflex_components_core/base/bare.py, line 128:

<comment>This cached property becomes stale when `Bare.contents` is reassigned. `_contents_vars()` rebuilds the rendered var for a new contents identity, but imports, refs, custom code, dynamic imports, and compiler traversal still use the old component list; avoid caching this derived property or invalidate it whenever `contents` changes.</comment>

<file context>
@@ -146,16 +125,22 @@ def _get_all_app_wrap_components(
 
-    def _get_all_refs(self) -> dict[str, None]:
-        """Get the refs for the children of the component.
+    @functools.cached_property
+    def _get_component_prop_property(self) -> Sequence[BaseComponent]:
+        """The components of the props and of the var rendered for the contents.
</file context>

def _get_component_prop_property(self) -> Sequence[BaseComponent]:
"""The components of the props and of the var rendered for the contents.

The compiler and the import, custom code, dynamic import and ref collectors
follow this traversal, so components a custom ``to_string()`` brings count.

Returns:
Each component of the props, then the rendered var's others.
"""
components = super()._get_component_prop_property
seen = {id(component) for component in components}
return [
*components,
*(c for c in self._contents_components() if id(c) not in seen),
]

def _contents_vars(self) -> tuple[Var, ...]:
"""The contents and, when it differs, the var rendered for them, built once.

The rendered var shows booleans and objects as their string form.

Returns:
The refs for the children.
The vars, the rendered one last.
"""
contents = self.contents
cached = self.__dict__.get("_vars_cache")
# The base class's vars cache, dropped with the other compile caches;
# keyed on the contents too, so reassigning them never renders stale.
if cached is not None and cached[0] is contents:
return cached
rendered = contents if isinstance(contents, Var) else Var.create(contents)
if isinstance(rendered, (BooleanVar, ObjectVar)):
rendered = rendered.to_string()
cached = (contents,) if rendered is contents else (contents, rendered)
self._vars_cache = cached
return cached

def _contents_components(self) -> Iterator[BaseComponent]:
"""The components carried by the contents and the var rendered for them.

A custom ``to_string()`` can bring components the contents lack.

Yields:
Each component once, those of the contents first.
"""
refs = super()._get_all_refs()
if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
refs |= component._get_all_refs()
return refs
seen: set[int] = set()
for var in self._contents_vars():
for component in _components_from_var(var):
if id(component) not in seen:
seen.add(id(component))
yield component
Comment thread
benedikt-bartscher marked this conversation as resolved.
Resolved

def _render(self) -> CommonTag:
contents = (
Var.create(self.contents)
if not isinstance(self.contents, Var)
else self.contents
)
if isinstance(contents, (BooleanVar, ObjectVar)):
return Tagless(contents=f"{contents.to_string()!s}")
return Tagless(contents=f"{contents!s}")
return Tagless(contents=f"{self._contents_vars()[-1]!s}")

def render(self) -> dict:
"""Render the component as a dictionary.
Expand All @@ -198,14 +189,7 @@ def render(self) -> dict:
Returns:
The rendered component.
"""
contents = (
Var.create(self.contents)
if not isinstance(self.contents, Var)
else self.contents
)
if isinstance(contents, (BooleanVar, ObjectVar)):
return {"contents": f"{contents.to_string()!s}"}
return {"contents": f"{contents!s}"}
return {"contents": f"{self._contents_vars()[-1]!s}"}

def _add_style_recursive(
self, style: ComponentStyle, theme: Component | None = None
Expand All @@ -223,11 +207,10 @@ def _add_style_recursive(

are_components_touched = False

if isinstance(self.contents, Var):
for component in _components_from_var(self.contents):
if isinstance(component, Component):
component._add_style_recursive(style, theme)
are_components_touched = True
for component in self._contents_components():
if isinstance(component, Component):
component._add_style_recursive(style, theme)
are_components_touched = True

if are_components_touched:
GLOBAL_CACHE.clear()
Expand All @@ -244,6 +227,6 @@ def _get_vars(
ignore_ids: The ids to ignore.

Yields:
The contents if it is a Var, otherwise nothing.
The contents, and the var rendered for them when that differs.
"""
yield self.contents
yield from self._contents_vars()
Comment thread
cubic-dev-ai[bot] marked this conversation as resolved.
Resolved
134 changes: 133 additions & 1 deletion tests/units/components/base/test_bare.py
Original file line number Diff line number Diff line change
@@ -1,5 +1,10 @@
import pytest
from reflex_base.vars.base import Var
from reflex_base.components.component import Component
from reflex_base.components.tags.tagless import Tagless
from reflex_base.utils.imports import ImportVar
from reflex_base.vars import ObjectVar
from reflex_base.vars.base import Var, VarData
from reflex_base.vars.sequence import StringVar
from reflex_components_core.base.bare import Bare

STATE_VAR = Var(_js_expr="default_state.name")
Expand All @@ -23,3 +28,130 @@ def test_fstrings(contents, expected):
"""
comp = Bare.create(contents).render()
assert comp["contents"] == expected


TEXTS_HOOK = "const texts = useTexts()"
PICK_HOOK = "const pick = usePick()"


class PickedVar(ObjectVar[dict]):
"""An object var whose string form needs another hook from the same library."""

def to_string(self, use_json: bool = True) -> StringVar:
"""Pick a text from the object with a hook.

Args:
use_json: Unused.

Returns:
The picked text.
"""
return Var(
_js_expr=f"pick({self!s})",
_var_data=VarData(
hooks={PICK_HOOK: None}, imports={"$/utils/i18n": ["usePick"]}
),
).to(str)


def test_rendered_string_form_brings_its_hooks_and_imports():
"""An object rendered through to_string carries that var's hooks and imports."""
texts = PickedVar(
_js_expr="texts",
_var_type=dict,
_var_data=VarData(
hooks={TEXTS_HOOK: None}, imports={"$/utils/i18n": ["useTexts"]}
),
)
comp = Bare.create(texts)

assert comp.render()["contents"] == "pick(texts)"
assert comp._get_all_hooks() == {TEXTS_HOOK: None, PICK_HOOK: None}
assert comp._get_all_imports(collapse=True) == {
"$/utils/i18n": [ImportVar(tag="useTexts"), ImportVar(tag="usePick")]
}


def test_string_form_is_built_once_per_contents():
"""The string form is built once per contents and shared by the vars and the render."""
comp = Bare.create(Var(_js_expr="flag", _var_type=bool).guess_type())
assert isinstance(comp, Bare)
contents, rendered = comp._get_vars()

assert contents is comp.contents
assert tuple(map(id, comp._get_vars())) == (id(contents), id(rendered))
assert str(rendered) == "(JSON.stringify(flag))"
assert comp.render() == {"contents": "(JSON.stringify(flag))"}
assert comp._render() == Tagless(contents="(JSON.stringify(flag))")

comp.contents = Var(_js_expr="items", _var_type=dict).guess_type()

assert comp.render() == {"contents": "(JSON.stringify(items))"}
assert [str(var) for var in comp._get_vars()] == [
"items",
"(JSON.stringify(items))",
]


BOX_HOOK = "const box = useBox()"
BOX_CODE = "const boxDefaults = {};"


class HookedBox(Component):
"""A component with a hook and custom code of its own."""

tag = "HookedBox"
library = "hooked-box"

def add_hooks(self) -> list[str]:
"""Add the box hook.

Returns:
The hooks.
"""
return [BOX_HOOK]

def add_custom_code(self) -> list[str]:
"""Add the box defaults.

Returns:
The custom code.
"""
return [BOX_CODE]


class BoxedVar(ObjectVar[dict]):
"""An object var whose string form renders through a component."""

def to_string(self, use_json: bool = True) -> StringVar:
"""Render the object through a box component.

Args:
use_json: Unused.

Returns:
The boxed text.
"""
return Var(
_js_expr=f"box({self!s})",
_var_data=VarData(components=(HookedBox.create(id="box"),)),
).to(str)


def test_rendered_string_form_brings_its_components():
"""Components carried by the string form count like those of the contents."""
comp = Bare.create(BoxedVar(_js_expr="data", _var_type=dict))

assert comp.render()["contents"] == "box(data)"
assert comp._get_all_hooks() == {
'const ref_box = useRegisteredRef("ref_box");': None,
BOX_HOOK: None,
}
assert comp._get_all_custom_code() == {BOX_CODE: None}
assert comp._get_all_refs() == {"ref_box": None}
# the compiler reaches the box's imports through the prop traversal too
assert [type(c) for c in comp._get_components_in_props()] == [HookedBox]
assert comp._get_all_imports(collapse=True) == {
"$/utils/state": [ImportVar(tag="useRegisteredRef")],
"hooked-box": [ImportVar(tag="HookedBox")],
}
Loading