reflex 0.6.0__py3-none-any.whl → 0.6.0a1__py3-none-any.whl

reflex/state.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import copy
-import dataclasses
 import functools
 import inspect
 import os
@@ -35,11 +34,11 @@ import dill
 from sqlalchemy.orm import DeclarativeBase
 
 from reflex.config import get_config
-from reflex.vars.base import (
-    ComputedVar,
+from reflex.ivars.base import (
     DynamicRouteVar,
-    Var,
-    computed_var,
+    ImmutableComputedVar,
+    ImmutableVar,
+    immutable_computed_var,
     is_computed_var,
 )
 
@@ -63,10 +62,7 @@ from reflex.event import (
 )
 from reflex.utils import console, format, path_ops, prerequisites, types
 from reflex.utils.exceptions import (
-    ComputedVarShadowsBaseVars,
-    ComputedVarShadowsStateVar,
     DynamicRouteArgShadowsStateVar,
-    EventHandlerShadowsBuiltInStateMethod,
     ImmutableStateError,
     LockExpiredError,
 )
@@ -80,22 +76,20 @@ if TYPE_CHECKING:
 
 
 Delta = Dict[str, Any]
-var = computed_var
+var = immutable_computed_var
 
 
 # If the state is this large, it's considered a performance issue.
 TOO_LARGE_SERIALIZED_STATE = 100 * 1024  # 100kb
 
 
-@dataclasses.dataclass(frozen=True)
-class HeaderData:
+class HeaderData(Base):
     """An object containing headers data."""
 
     host: str = ""
     origin: str = ""
     upgrade: str = ""
     connection: str = ""
-    cookie: str = ""
     pragma: str = ""
     cache_control: str = ""
     user_agent: str = ""
@@ -111,16 +105,13 @@ class HeaderData:
         Args:
             router_data: the router_data dict.
         """
+        super().__init__()
         if router_data:
             for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items():
-                object.__setattr__(self, format.to_snake_case(k), v)
-        else:
-            for k in dataclasses.fields(self):
-                object.__setattr__(self, k.name, "")
+                setattr(self, format.to_snake_case(k), v)
 
 
-@dataclasses.dataclass(frozen=True)
-class PageData:
+class PageData(Base):
     """An object containing page data."""
 
     host: str = ""  # repeated with self.headers.origin (remove or keep the duplicate?)
@@ -128,7 +119,7 @@ class PageData:
     raw_path: str = ""
     full_path: str = ""
     full_raw_path: str = ""
-    params: dict = dataclasses.field(default_factory=dict)
+    params: dict = {}
 
     def __init__(self, router_data: Optional[dict] = None):
         """Initalize the PageData object based on router_data.
@@ -136,34 +127,17 @@ class PageData:
         Args:
             router_data: the router_data dict.
         """
+        super().__init__()
         if router_data:
-            object.__setattr__(
-                self,
-                "host",
-                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", ""),
-            )
-            object.__setattr__(
-                self, "path", router_data.get(constants.RouteVar.PATH, "")
-            )
-            object.__setattr__(
-                self, "raw_path", router_data.get(constants.RouteVar.ORIGIN, "")
-            )
-            object.__setattr__(self, "full_path", f"{self.host}{self.path}")
-            object.__setattr__(self, "full_raw_path", f"{self.host}{self.raw_path}")
-            object.__setattr__(
-                self, "params", router_data.get(constants.RouteVar.QUERY, {})
-            )
-        else:
-            object.__setattr__(self, "host", "")
-            object.__setattr__(self, "path", "")
-            object.__setattr__(self, "raw_path", "")
-            object.__setattr__(self, "full_path", "")
-            object.__setattr__(self, "full_raw_path", "")
-            object.__setattr__(self, "params", {})
+            self.host = router_data.get(constants.RouteVar.HEADERS, {}).get("origin")
+            self.path = router_data.get(constants.RouteVar.PATH, "")
+            self.raw_path = router_data.get(constants.RouteVar.ORIGIN, "")
+            self.full_path = f"{self.host}{self.path}"
+            self.full_raw_path = f"{self.host}{self.raw_path}"
+            self.params = router_data.get(constants.RouteVar.QUERY, {})
 
 
-@dataclasses.dataclass(frozen=True, init=False)
-class SessionData:
+class SessionData(Base):
     """An object containing session data."""
 
     client_token: str = ""
@@ -176,24 +150,19 @@ class SessionData:
         Args:
             router_data: the router_data dict.
         """
+        super().__init__()
         if router_data:
-            client_token = router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
-            client_ip = router_data.get(constants.RouteVar.CLIENT_IP, "")
-            session_id = router_data.get(constants.RouteVar.SESSION_ID, "")
-        else:
-            client_token = client_ip = session_id = ""
-        object.__setattr__(self, "client_token", client_token)
-        object.__setattr__(self, "client_ip", client_ip)
-        object.__setattr__(self, "session_id", session_id)
+            self.client_token = router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
+            self.client_ip = router_data.get(constants.RouteVar.CLIENT_IP, "")
+            self.session_id = router_data.get(constants.RouteVar.SESSION_ID, "")
 
 
-@dataclasses.dataclass(frozen=True, init=False)
-class RouterData:
+class RouterData(Base):
     """An object containing RouterData."""
 
-    session: SessionData = dataclasses.field(default_factory=SessionData)
-    headers: HeaderData = dataclasses.field(default_factory=HeaderData)
-    page: PageData = dataclasses.field(default_factory=PageData)
+    session: SessionData = SessionData()
+    headers: HeaderData = HeaderData()
+    page: PageData = PageData()
 
     def __init__(self, router_data: Optional[dict] = None):
         """Initialize the RouterData object.
@@ -201,9 +170,10 @@ class RouterData:
         Args:
             router_data: the router_data dict.
         """
-        object.__setattr__(self, "session", SessionData(router_data))
-        object.__setattr__(self, "headers", HeaderData(router_data))
-        object.__setattr__(self, "page", PageData(router_data))
+        super().__init__()
+        self.session = SessionData(router_data)
+        self.headers = HeaderData(router_data)
+        self.page = PageData(router_data)
 
 
 def _no_chain_background_task(
@@ -279,11 +249,10 @@ def _split_substate_key(substate_key: str) -> tuple[str, str]:
     return token, state_name
 
 
-@dataclasses.dataclass(frozen=True, init=False)
 class EventHandlerSetVar(EventHandler):
     """A special event handler to wrap setvar functionality."""
 
-    state_cls: Type[BaseState] = dataclasses.field(init=False)
+    state_cls: Type[BaseState]
 
     def __init__(self, state_cls: Type[BaseState]):
         """Initialize the EventHandlerSetVar.
@@ -294,8 +263,8 @@ class EventHandlerSetVar(EventHandler):
         super().__init__(
             fn=type(self).setvar,
             state_full_name=state_cls.get_full_name(),
+            state_cls=state_cls,  # type: ignore
         )
-        object.__setattr__(self, "state_cls", state_cls)
 
     def setvar(self, var_name: str, value: Any):
         """Set the state variable to the value of the event.
@@ -340,16 +309,16 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     """The state of the app."""
 
     # A map from the var name to the var.
-    vars: ClassVar[Dict[str, Var]] = {}
+    vars: ClassVar[Dict[str, ImmutableVar]] = {}
 
     # The base vars of the class.
-    base_vars: ClassVar[Dict[str, Var]] = {}
+    base_vars: ClassVar[Dict[str, ImmutableVar]] = {}
 
     # The computed vars of the class.
-    computed_vars: ClassVar[Dict[str, ComputedVar]] = {}
+    computed_vars: ClassVar[Dict[str, ImmutableComputedVar]] = {}
 
     # Vars inherited by the parent state.
-    inherited_vars: ClassVar[Dict[str, Var]] = {}
+    inherited_vars: ClassVar[Dict[str, ImmutableVar]] = {}
 
     # Backend base vars that are never sent to the client.
     backend_vars: ClassVar[Dict[str, Any]] = {}
@@ -459,7 +428,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return f"{self.__class__.__name__}({self.dict()})"
 
     @classmethod
-    def _get_computed_vars(cls) -> list[ComputedVar]:
+    def _get_computed_vars(cls) -> list[ImmutableComputedVar]:
         """Helper function to get all computed vars of a instance.
 
         Returns:
@@ -556,8 +525,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         # Set the base and computed vars.
         cls.base_vars = {
-            f.name: Var(
-                _js_expr=format.format_state_name(cls.get_full_name()) + "." + f.name,
+            f.name: ImmutableVar(
+                _var_name=format.format_state_name(cls.get_full_name()) + "." + f.name,
                 _var_type=f.outer_type_,
                 _var_data=VarData.from_state(cls),
             ).guess_type()
@@ -565,7 +534,7 @@ 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))
+            v._var_name: v._replace(merge_var_data=VarData.from_state(cls))
             for v in computed_vars
         }
         cls.vars = {
@@ -595,8 +564,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                     newcv = value._replace(fget=fget, _var_data=VarData.from_state(cls))
                     # cleanup refs to mixin cls in var_data
                     setattr(cls, name, newcv)
-                    cls.computed_vars[newcv._js_expr] = newcv
-                    cls.vars[newcv._js_expr] = newcv
+                    cls.computed_vars[newcv._var_name] = newcv
+                    cls.vars[newcv._var_name] = newcv
                     continue
                 if types.is_backend_base_variable(name, mixin):
                     cls.backend_vars[name] = copy.deepcopy(value)
@@ -736,7 +705,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """Check for shadow methods and raise error if any.
 
         Raises:
-            EventHandlerShadowsBuiltInStateMethod: When an event handler shadows an inbuilt state method.
+            NameError: When an event handler shadows an inbuilt state method.
         """
         overridden_methods = set()
         state_base_functions = cls._get_base_functions()
@@ -750,7 +719,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 overridden_methods.add(method.__name__)
 
         for method_name in overridden_methods:
-            raise EventHandlerShadowsBuiltInStateMethod(
+            raise NameError(
                 f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
             )
 
@@ -759,12 +728,12 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """Check for shadow base vars and raise error if any.
 
         Raises:
-            ComputedVarShadowsBaseVars: When a computed var shadows a base var.
+            NameError: When a computed var shadows a base var.
         """
         for computed_var_ in cls._get_computed_vars():
-            if computed_var_._js_expr in cls.__annotations__:
-                raise ComputedVarShadowsBaseVars(
-                    f"The computed var name `{computed_var_._js_expr}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
+            if computed_var_._var_name in cls.__annotations__:
+                raise NameError(
+                    f"The computed var name `{computed_var_._var_name}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
                 )
 
     @classmethod
@@ -772,15 +741,15 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """Check for shadow computed vars and raise error if any.
 
         Raises:
-            ComputedVarShadowsStateVar: When a computed var shadows another.
+            NameError: When a computed var shadows another.
         """
         for name, cv in cls.__dict__.items():
             if not is_computed_var(cv):
                 continue
-            name = cv._js_expr
+            name = cv._var_name
             if name in cls.inherited_vars or name in cls.inherited_backend_vars:
-                raise ComputedVarShadowsStateVar(
-                    f"The computed var name `{cv._js_expr}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
+                raise NameError(
+                    f"The computed var name `{cv._var_name}` shadows a var in {cls.__module__}.{cls.__name__}; use a different name instead"
                 )
 
     @classmethod
@@ -902,7 +871,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return getattr(substate, name)
 
     @classmethod
-    def _init_var(cls, prop: Var):
+    def _init_var(cls, prop: ImmutableVar):
         """Initialize a variable.
 
         Args:
@@ -918,7 +887,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 "State vars must be primitive Python types, "
                 "Plotly figures, Pandas dataframes, "
                 "or subclasses of rx.Base. "
-                f'Found var "{prop._js_expr}" with type {prop._var_type}.'
+                f'Found var "{prop._var_name}" with type {prop._var_type}.'
             )
         cls._set_var(prop)
         cls._create_setter(prop)
@@ -945,8 +914,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             )
 
         # create the variable based on name and type
-        var = Var(
-            _js_expr=format.format_state_name(cls.get_full_name()) + "." + name,
+        var = ImmutableVar(
+            _var_name=format.format_state_name(cls.get_full_name()) + "." + name,
             _var_type=type_,
             _var_data=VarData.from_state(cls),
         ).guess_type()
@@ -968,14 +937,16 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         cls._init_var_dependency_dicts()
 
     @classmethod
-    def _set_var(cls, prop: Var):
+    def _set_var(cls, prop: ImmutableVar):
         """Set the var as a class member.
 
         Args:
             prop: The var instance to set.
         """
         acutal_var_name = (
-            prop._js_expr if "." not in prop._js_expr else prop._js_expr.split(".")[-1]
+            prop._var_name
+            if "." not in prop._var_name
+            else prop._var_name.split(".")[-1]
         )
         setattr(cls, acutal_var_name, prop)
 
@@ -997,7 +968,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         cls.setvar = cls.event_handlers["setvar"] = EventHandlerSetVar(state_cls=cls)
 
     @classmethod
-    def _create_setter(cls, prop: Var):
+    def _create_setter(cls, prop: ImmutableVar):
         """Create a setter for the var.
 
         Args:
@@ -1010,17 +981,17 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             setattr(cls, setter_name, event_handler)
 
     @classmethod
-    def _set_default_value(cls, prop: Var):
+    def _set_default_value(cls, prop: ImmutableVar):
         """Set the default value for the var.
 
         Args:
             prop: The var to set the default value for.
         """
         # Get the pydantic field for the var.
-        if "." in prop._js_expr:
-            field = cls.get_fields()[prop._js_expr.split(".")[-1]]
+        if "." in prop._var_name:
+            field = cls.get_fields()[prop._var_name.split(".")[-1]]
         else:
-            field = cls.get_fields()[prop._js_expr]
+            field = cls.get_fields()[prop._var_name]
         if field.required:
             default_value = prop.get_default_value()
             if default_value is not None:
@@ -1047,27 +1018,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if not func[0].startswith("__")
         }
 
-    @classmethod
-    def _update_substate_inherited_vars(cls, vars_to_add: dict[str, Var]):
-        """Update the inherited vars of substates recursively when new vars are added.
-
-        Also updates the var dependency tracking dicts after adding vars.
-
-        Args:
-            vars_to_add: names to Var instances to add to substates
-        """
-        for substate_class in cls.class_subclasses:
-            for name, var in vars_to_add.items():
-                if types.is_backend_base_variable(name, cls):
-                    substate_class.backend_vars.setdefault(name, var)
-                    substate_class.inherited_backend_vars.setdefault(name, var)
-                else:
-                    substate_class.vars.setdefault(name, var)
-                    substate_class.inherited_vars.setdefault(name, var)
-                substate_class._update_substate_inherited_vars(vars_to_add)
-        # Reinitialize dependency tracking dicts.
-        cls._init_var_dependency_dicts()
-
     @classmethod
     def setup_dynamic_args(cls, args: dict[str, str]):
         """Set up args for easy access in renderer.
@@ -1084,15 +1034,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             def inner_func(self) -> str:
                 return self.router.page.params.get(param, "")
 
-            return inner_func
+            return DynamicRouteVar(fget=inner_func, cache=True)
 
         def arglist_factory(param):
             def inner_func(self) -> List[str]:
                 return self.router.page.params.get(param, [])
 
-            return inner_func
+            return DynamicRouteVar(fget=inner_func, cache=True)
 
-        dynamic_vars = {}
         for param, value in args.items():
             if value == constants.RouteArgType.SINGLE:
                 func = argsingle_factory(param)
@@ -1100,18 +1049,16 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 func = arglist_factory(param)
             else:
                 continue
-            dynamic_vars[param] = DynamicRouteVar(
-                fget=func,
-                cache=True,
-                _js_expr=param,
-                _var_data=VarData.from_state(cls),
+            # to allow passing as a prop, evade python frozen rules (bad practice)
+            object.__setattr__(func, "_var_name", param)
+            # cls.vars[param] = cls.computed_vars[param] = func._var_set_state(cls)  # type: ignore
+            cls.vars[param] = cls.computed_vars[param] = func._replace(
+                _var_data=VarData.from_state(cls)
             )
-            setattr(cls, param, dynamic_vars[param])
+            setattr(cls, param, func)
 
-        # Update tracking dicts.
-        cls.computed_vars.update(dynamic_vars)
-        cls.vars.update(dynamic_vars)
-        cls._update_substate_inherited_vars(dynamic_vars)
+        # Reinitialize dependency tracking dicts.
+        cls._init_var_dependency_dicts()
 
     @classmethod
     def _check_overwritten_dynamic_args(cls, args: list[str]):
@@ -1879,13 +1826,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             self.dirty_vars.update(self._always_dirty_computed_vars)
             self._mark_dirty()
 
-        def dictify(value: Any):
-            if dataclasses.is_dataclass(value) and not isinstance(value, type):
-                return dataclasses.asdict(value)
-            return value
-
         base_vars = {
-            prop_name: dictify(self.get_value(getattr(self, prop_name)))
+            prop_name: self.get_value(getattr(self, prop_name))
             for prop_name in self.base_vars
         }
         if initial and include_computed:
@@ -1965,6 +1907,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return state
 
 
+EventHandlerSetVar.update_forward_refs()
+
+
 class State(BaseState):
     """The app Base State."""
 
@@ -2396,29 +2341,18 @@ class StateProxy(wrapt.ObjectProxy):
             self._self_mutable = original_mutable
 
 
-@dataclasses.dataclass(
-    frozen=True,
-)
-class StateUpdate:
+class StateUpdate(Base):
     """A state update sent to the frontend."""
 
     # The state delta.
-    delta: Delta = dataclasses.field(default_factory=dict)
+    delta: Delta = {}
 
     # Events to be added to the event queue.
-    events: List[Event] = dataclasses.field(default_factory=list)
+    events: List[Event] = []
 
     # Whether this is the final state update for the event.
     final: bool = True
 
-    def json(self) -> str:
-        """Convert the state update to a JSON string.
-
-        Returns:
-            The state update as a JSON string.
-        """
-        return format.json_dumps(dataclasses.asdict(self))
-
 
 class StateManager(Base, ABC):
     """A class to manage many client states."""

reflex/style.py

@@ -7,12 +7,12 @@ from typing import Any, Literal, Tuple, Type
 from reflex import constants
 from reflex.components.core.breakpoints import Breakpoints, breakpoints_values
 from reflex.event import EventChain, EventHandler
+from reflex.ivars.base import ImmutableCallableVar, ImmutableVar, LiteralVar
+from reflex.ivars.function import FunctionVar
 from reflex.utils import format
 from reflex.utils.exceptions import ReflexError
 from reflex.utils.imports import ImportVar
-from reflex.vars import VarData
-from reflex.vars.base import CallableVar, LiteralVar, Var
-from reflex.vars.function import FunctionVar
+from reflex.vars import Var, VarData
 
 SYSTEM_COLOR_MODE: str = "system"
 LIGHT_COLOR_MODE: str = "light"
@@ -26,30 +26,30 @@ color_mode_imports = {
 }
 
 
-def _color_mode_var(_js_expr: str, _var_type: Type = str) -> Var:
-    """Create a Var that destructs the _js_expr from ColorModeContext.
+def _color_mode_var(_var_name: str, _var_type: Type = str) -> ImmutableVar:
+    """Create a Var that destructs the _var_name from ColorModeContext.
 
     Args:
-        _js_expr: The name of the variable to get from ColorModeContext.
+        _var_name: The name of the variable to get from ColorModeContext.
         _var_type: The type of the Var.
 
     Returns:
         The Var that resolves to the color mode.
     """
-    return Var(
-        _js_expr=_js_expr,
+    return ImmutableVar(
+        _var_name=_var_name,
         _var_type=_var_type,
         _var_data=VarData(
             imports=color_mode_imports,
-            hooks={f"const {{ {_js_expr} }} = useContext(ColorModeContext)": None},
+            hooks={f"const {{ {_var_name} }} = useContext(ColorModeContext)": None},
         ),
     ).guess_type()
 
 
-@CallableVar
+@ImmutableCallableVar
 def set_color_mode(
     new_color_mode: LiteralColorMode | Var[LiteralColorMode] | None = None,
-) -> Var[EventChain]:
+) -> ImmutableVar[EventChain]:
     """Create an EventChain Var that sets the color mode to a specific value.
 
     Note: `set_color_mode` is not a real event and cannot be triggered from a
@@ -62,16 +62,16 @@ def set_color_mode(
         The EventChain Var that can be passed to an event trigger.
     """
     base_setter = _color_mode_var(
-        _js_expr=constants.ColorMode.SET,
+        _var_name=constants.ColorMode.SET,
         _var_type=EventChain,
     )
     if new_color_mode is None:
         return base_setter
 
-    if not isinstance(new_color_mode, Var):
+    if not isinstance(new_color_mode, ImmutableVar):
         new_color_mode = LiteralVar.create(new_color_mode)
 
-    return Var(
+    return ImmutableVar(
         f"() => {str(base_setter)}({str(new_color_mode)})",
         _var_data=VarData.merge(
             base_setter._get_all_var_data(), new_color_mode._get_all_var_data()
@@ -80,12 +80,12 @@ def set_color_mode(
 
 
 # Var resolves to the current color mode for the app ("light", "dark" or "system")
-color_mode = _color_mode_var(_js_expr=constants.ColorMode.NAME)
+color_mode = _color_mode_var(_var_name=constants.ColorMode.NAME)
 # Var resolves to the resolved color mode for the app ("light" or "dark")
-resolved_color_mode = _color_mode_var(_js_expr=constants.ColorMode.RESOLVED_NAME)
+resolved_color_mode = _color_mode_var(_var_name=constants.ColorMode.RESOLVED_NAME)
 # Var resolves to a function invocation that toggles the color mode
 toggle_color_mode = _color_mode_var(
-    _js_expr=constants.ColorMode.TOGGLE,
+    _var_name=constants.ColorMode.TOGGLE,
     _var_type=EventChain,
 )
 
@@ -115,7 +115,7 @@ def media_query(breakpoint_expr: str):
 
 def convert_item(
     style_item: int | str | Var,
-) -> tuple[str | Var, VarData | None]:
+) -> tuple[str | Var, VarData | VarData | None]:
     """Format a single value in a style dictionary.
 
     Args:
@@ -133,7 +133,7 @@ def convert_item(
             "Please use a Var or a literal value."
         )
 
-    if isinstance(style_item, Var):
+    if isinstance(style_item, ImmutableVar):
         return style_item, style_item._get_all_var_data()
 
     # if isinstance(style_item, str) and REFLEX_VAR_OPENING_TAG not in style_item:
@@ -146,7 +146,7 @@ def convert_item(
 
 
 def convert_list(
-    responsive_list: list[str | dict | Var],
+    responsive_list: list[str | dict | ImmutableVar],
 ) -> tuple[list[str | dict[str, Var | list | dict]], VarData | None]:
     """Format a responsive value list.
 
@@ -189,7 +189,7 @@ def convert(
 
     for key, value in style_dict.items():
         keys = format_style_key(key)
-        if isinstance(value, Var):
+        if isinstance(value, ImmutableVar):
             return_val = value
             new_var_data = value._get_all_var_data()
             update_out_dict(return_val, keys)
@@ -290,6 +290,7 @@ def _format_emotion_style_pseudo_selector(key: str) -> str:
     """
     prefix = None
     if key.startswith("_"):
+        # Handle pseudo selectors in chakra style format.
         prefix = "&:"
         key = key[1:]
     if key.startswith(":"):

reflex/utils/exceptions.py

@@ -91,23 +91,3 @@ class EventFnArgMismatch(ReflexError, TypeError):
 
 class DynamicRouteArgShadowsStateVar(ReflexError, NameError):
     """Raised when a dynamic route arg shadows a state var."""
-
-
-class ComputedVarShadowsStateVar(ReflexError, NameError):
-    """Raised when a computed var shadows a state var."""
-
-
-class ComputedVarShadowsBaseVars(ReflexError, NameError):
-    """Raised when a computed var shadows a base var."""
-
-
-class EventHandlerShadowsBuiltInStateMethod(ReflexError, NameError):
-    """Raised when an event handler shadows a built-in state method."""
-
-
-class GeneratedCodeHasNoFunctionDefs(ReflexError):
-    """Raised when refactored code generated with flexgen has no functions defined."""
-
-
-class PrimitiveUnserializableToJSON(ReflexError, ValueError):
-    """Raised when a primitive type is unserializable to JSON. Usually with NaN and Infinity."""