reflex 0.5.10a3__py3-none-any.whl → 0.6.0a1__py3-none-any.whl

reflex/event.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import inspect
+import types
 import urllib.parse
 from base64 import b64encode
 from typing import (
@@ -18,9 +19,13 @@ from typing import (
 
 from reflex import constants
 from reflex.base import Base
+from reflex.ivars.base import ImmutableVar, LiteralVar
+from reflex.ivars.function import FunctionStringVar, FunctionVar
+from reflex.ivars.object import ObjectVar
 from reflex.utils import format
+from reflex.utils.exceptions import EventFnArgMismatch, EventHandlerArgMismatch
 from reflex.utils.types import ArgsSpec
-from reflex.vars import BaseVar, Var
+from reflex.vars import Var, VarData
 
 try:
     from typing import Annotated
@@ -186,7 +191,7 @@ class EventHandler(EventActionsMixin):
 
         # Get the function args.
         fn_args = inspect.getfullargspec(self.fn).args[1:]
-        fn_args = (Var.create_safe(arg, _var_is_string=False) for arg in fn_args)
+        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
@@ -197,7 +202,7 @@ class EventHandler(EventActionsMixin):
 
             # Otherwise, convert to JSON.
             try:
-                values.append(Var.create(arg, _var_is_string=isinstance(arg, str)))
+                values.append(LiteralVar.create(arg))
             except TypeError as e:
                 raise EventHandlerTypeError(
                     f"Arguments to event handlers must be Vars or JSON-serializable. Got {arg} of type {type(arg)}."
@@ -224,7 +229,7 @@ class EventSpec(EventActionsMixin):
     client_handler_name: str = ""
 
     # The arguments to pass to the function.
-    args: Tuple[Tuple[Var, Var], ...] = ()
+    args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...] = ()
 
     class Config:
         """The Pydantic config."""
@@ -232,7 +237,9 @@ class EventSpec(EventActionsMixin):
         # Required to allow tuple fields.
         frozen = True
 
-    def with_args(self, args: Tuple[Tuple[Var, Var], ...]) -> EventSpec:
+    def with_args(
+        self, args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...]
+    ) -> EventSpec:
         """Copy the event spec, with updated args.
 
         Args:
@@ -248,7 +255,7 @@ class EventSpec(EventActionsMixin):
             event_actions=self.event_actions.copy(),
         )
 
-    def add_args(self, *args: Var) -> EventSpec:
+    def add_args(self, *args: ImmutableVar) -> EventSpec:
         """Add arguments to the event spec.
 
         Args:
@@ -264,13 +271,13 @@ class EventSpec(EventActionsMixin):
 
         # Get the remaining unfilled function args.
         fn_args = inspect.getfullargspec(self.handler.fn).args[1 + len(self.args) :]
-        fn_args = (Var.create_safe(arg, _var_is_string=False) for arg in fn_args)
+        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
         for arg in args:
             try:
-                values.append(Var.create(arg, _var_is_string=isinstance(arg, str)))
+                values.append(LiteralVar.create(arg))
             except TypeError as e:
                 raise EventHandlerTypeError(
                     f"Arguments to event handlers must be Vars or JSON-serializable. Got {arg} of type {type(arg)}."
@@ -388,15 +395,16 @@ class FileUpload(Base):
         upload_id = self.upload_id or DEFAULT_UPLOAD_ID
         spec_args = [
             (
-                Var.create_safe("files", _var_is_string=False),
-                Var.create_safe(
-                    f"filesById[{Var.create_safe(upload_id, _var_is_string=True)._var_name_unwrapped}]",
-                    _var_is_string=False,
-                )._replace(_var_data=upload_files_context_var_data),
+                ImmutableVar.create_safe("files"),
+                ImmutableVar(
+                    _var_name="filesById",
+                    _var_type=Dict[str, Any],
+                    _var_data=VarData.merge(upload_files_context_var_data),
+                ).to(ObjectVar)[LiteralVar.create(upload_id)],
             ),
             (
-                Var.create_safe("upload_id", _var_is_string=False),
-                Var.create_safe(upload_id, _var_is_string=True),
+                ImmutableVar.create_safe("upload_id"),
+                LiteralVar.create(upload_id),
             ),
         ]
         if self.on_upload_progress is not None:
@@ -415,7 +423,7 @@ class FileUpload(Base):
                 )  # type: ignore
             else:
                 raise ValueError(f"{on_upload_progress} is not a valid event handler.")
-            if isinstance(events, Var):
+            if isinstance(events, ImmutableVar):
                 raise ValueError(f"{on_upload_progress} cannot return a var {events}.")
             on_upload_progress_chain = EventChain(
                 events=events,
@@ -424,11 +432,10 @@ class FileUpload(Base):
             formatted_chain = str(format.format_prop(on_upload_progress_chain))
             spec_args.append(
                 (
-                    Var.create_safe("on_upload_progress", _var_is_string=False),
-                    BaseVar(
-                        _var_name=formatted_chain.strip("{}"),
-                        _var_type=EventChain,
-                    ),
+                    ImmutableVar.create_safe("on_upload_progress"),
+                    FunctionStringVar(
+                        formatted_chain.strip("{}"),
+                    ).to(FunctionVar, EventChain),
                 ),
             )
         return EventSpec(
@@ -465,8 +472,8 @@ def server_side(name: str, sig: inspect.Signature, **kwargs) -> EventSpec:
         handler=EventHandler(fn=fn),
         args=tuple(
             (
-                Var.create_safe(k, _var_is_string=False),
-                Var.create_safe(v, _var_is_string=isinstance(v, str)),
+                ImmutableVar.create_safe(k),
+                LiteralVar.create(v),
             )
             for k, v in kwargs.items()
         ),
@@ -542,7 +549,7 @@ def set_focus(ref: str) -> EventSpec:
     return server_side(
         "_set_focus",
         get_fn_signature(set_focus),
-        ref=Var.create_safe(format.format_ref(ref), _var_is_string=True),
+        ref=LiteralVar.create(format.format_ref(ref)),
     )
 
 
@@ -573,7 +580,7 @@ def set_value(ref: str, value: Any) -> EventSpec:
     return server_side(
         "_set_value",
         get_fn_signature(set_value),
-        ref=Var.create_safe(format.format_ref(ref), _var_is_string=True),
+        ref=LiteralVar.create(format.format_ref(ref)),
         value=value,
     )
 
@@ -671,9 +678,9 @@ def set_clipboard(content: str) -> EventSpec:
 
 
 def download(
-    url: str | Var | None = None,
-    filename: Optional[str | Var] = None,
-    data: str | bytes | Var | None = None,
+    url: str | ImmutableVar | None = None,
+    filename: Optional[str | ImmutableVar] = None,
+    data: str | bytes | ImmutableVar | None = None,
 ) -> EventSpec:
     """Download the file at a given path or with the specified data.
 
@@ -709,21 +716,17 @@ def download(
         if isinstance(data, str):
             # Caller provided a plain text string to download.
             url = "data:text/plain," + urllib.parse.quote(data)
-        elif isinstance(data, Var):
+        elif isinstance(data, ImmutableVar):
             # Need to check on the frontend if the Var already looks like a data: URI.
-            is_data_url = data._replace(
-                _var_name=(
-                    f"typeof {data._var_full_name} == 'string' && "
-                    f"{data._var_full_name}.startsWith('data:')"
-                ),
-                _var_type=bool,
-                _var_is_string=False,
-                _var_full_name_needs_state_prefix=False,
-            )
+
+            is_data_url = (data.js_type() == "string") & (
+                data.to(str).startswith("data:")
+            )  # type: ignore
+
             # If it's a data: URI, use it as is, otherwise convert the Var to JSON in a data: URI.
             url = cond(  # type: ignore
                 is_data_url,
-                data,
+                data.to(str),
                 "data:text/plain," + data.to_string(),  # type: ignore
             )
         elif isinstance(data, bytes):
@@ -757,11 +760,13 @@ def _callback_arg_spec(eval_result):
 
 def call_script(
     javascript_code: str | Var[str],
-    callback: EventSpec
-    | EventHandler
-    | Callable
-    | List[EventSpec | EventHandler | Callable]
-    | None = None,
+    callback: (
+        EventSpec
+        | EventHandler
+        | Callable
+        | List[EventSpec | EventHandler | Callable]
+        | None
+    ) = None,
 ) -> EventSpec:
     """Create an event handler that executes arbitrary javascript code.
 
@@ -830,7 +835,7 @@ def call_event_handler(
         arg_spec: The lambda that define the argument(s) to pass to the event handler.
 
     Raises:
-        ValueError: if number of arguments expected by event_handler doesn't match the spec.
+        EventHandlerArgMismatch: if number of arguments expected by event_handler doesn't match the spec.
 
     Returns:
         The event spec from calling the event handler.
@@ -842,13 +847,16 @@ def call_event_handler(
         return event_handler.add_args(*parsed_args)
 
     args = inspect.getfullargspec(event_handler.fn).args
-    if len(args) == len(["self", *parsed_args]):
+    n_args = len(args) - 1  # subtract 1 for bound self arg
+    if n_args == len(parsed_args):
         return event_handler(*parsed_args)  # type: ignore
     else:
-        source = inspect.getsource(arg_spec)  # type: ignore
-        raise ValueError(
-            f"number of arguments in {event_handler.fn.__qualname__} "
-            f"doesn't match the definition of the event trigger '{source.strip().strip(',')}'"
+        raise EventHandlerArgMismatch(
+            "The number of arguments accepted by "
+            f"{event_handler.fn.__qualname__} ({n_args}) "
+            "does not match the arguments passed by the event trigger: "
+            f"{[str(v) for v in parsed_args]}\n"
+            "See https://reflex.dev/docs/events/event-arguments/"
         )
 
 
@@ -865,68 +873,68 @@ def parse_args_spec(arg_spec: ArgsSpec):
     annotations = get_type_hints(arg_spec)
     return arg_spec(
         *[
-            BaseVar(
-                _var_name=f"_{l_arg}",
-                _var_type=annotations.get(l_arg, FrontendEvent),
-                _var_is_local=True,
+            ImmutableVar(f"_{l_arg}").to(
+                ObjectVar, annotations.get(l_arg, FrontendEvent)
             )
             for l_arg in spec.args
         ]
     )
 
 
-def call_event_fn(fn: Callable, arg: Union[Var, ArgsSpec]) -> list[EventSpec] | Var:
+def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | ImmutableVar:
     """Call a function to a list of event specs.
 
     The function should return a single EventSpec, a list of EventSpecs, or a
-    single Var. If the function takes in an arg, the arg will be passed to the
-    function. Otherwise, the function will be called with no args.
+    single Var. The function signature must match the passed arg_spec or
+    EventFnArgsMismatch will be raised.
 
     Args:
         fn: The function to call.
-        arg: The argument to pass to the function.
+        arg_spec: The argument spec for the event trigger.
 
     Returns:
         The event specs from calling the function or a Var.
 
     Raises:
-        EventHandlerValueError: If the lambda has an invalid signature.
+        EventFnArgMismatch: If the function signature doesn't match the arg spec.
+        EventHandlerValueError: If the lambda returns an unusable value.
     """
     # Import here to avoid circular imports.
     from reflex.event import EventHandler, EventSpec
     from reflex.utils.exceptions import EventHandlerValueError
 
-    # Get the args of the lambda.
-    args = inspect.getfullargspec(fn).args
+    # Check that fn signature matches arg_spec
+    fn_args = inspect.getfullargspec(fn).args
+    n_fn_args = len(fn_args)
+    if isinstance(fn, types.MethodType):
+        n_fn_args -= 1  # subtract 1 for bound self arg
+    parsed_args = parse_args_spec(arg_spec)
+    if len(parsed_args) != n_fn_args:
+        raise EventFnArgMismatch(
+            "The number of arguments accepted by "
+            f"{fn} ({n_fn_args}) "
+            "does not match the arguments passed by the event trigger: "
+            f"{[str(v) for v in parsed_args]}\n"
+            "See https://reflex.dev/docs/events/event-arguments/"
+        )
 
-    if isinstance(arg, ArgsSpec):
-        out = fn(*parse_args_spec(arg))  # type: ignore
-    else:
-        # Call the lambda.
-        if len(args) == 0:
-            out = fn()
-        elif len(args) == 1:
-            out = fn(arg)
-        else:
-            raise EventHandlerValueError(f"Lambda {fn} must have 0 or 1 arguments.")
+    # Call the function with the parsed args.
+    out = fn(*parsed_args)
 
     # If the function returns a Var, assume it's an EventChain and render it directly.
-    if isinstance(out, Var):
+    if isinstance(out, ImmutableVar):
         return out
 
     # Convert the output to a list.
-    if not isinstance(out, List):
+    if not isinstance(out, list):
         out = [out]
 
     # Convert any event specs to event specs.
     events = []
     for e in out:
-        # Convert handlers to event specs.
         if isinstance(e, EventHandler):
-            if len(args) == 0:
-                e = e()
-            elif len(args) == 1:
-                e = e(arg)  # type: ignore
+            # An un-called EventHandler gets all of the args of the event trigger.
+            e = call_event_handler(e, arg_spec)
 
         # Make sure the event spec is valid.
         if not isinstance(e, EventSpec):
@@ -941,7 +949,9 @@ def call_event_fn(fn: Callable, arg: Union[Var, ArgsSpec]) -> list[EventSpec] |
     return events
 
 
-def get_handler_args(event_spec: EventSpec) -> tuple[tuple[Var, Var], ...]:
+def get_handler_args(
+    event_spec: EventSpec,
+) -> tuple[tuple[ImmutableVar, ImmutableVar], ...]:
     """Get the handler args for the given event spec.
 
     Args:

reflex/experimental/__init__.py

@@ -8,7 +8,6 @@ from reflex.components.sonner.toast import toast as toast
 
 from ..utils.console import warn
 from . import hooks as hooks
-from . import vars as vars
 from .assets import asset as asset
 from .client_state import ClientStateVar as ClientStateVar
 from .layout import layout as layout
@@ -33,19 +32,39 @@ class ExperimentalNamespace(SimpleNamespace):
         Returns:
             The toast namespace.
         """
-        if "toast" not in _EMITTED_PROMOTION_WARNINGS:
-            _EMITTED_PROMOTION_WARNINGS.add("toast")
-            warn(f"`rx._x.toast` was promoted to `rx.toast`.")
+        self.register_component_warning("toast")
         return toast
 
+    @property
+    def progress(self):
+        """Temporary property returning the toast namespace.
+
+        Remove this property when toast is fully promoted.
+
+        Returns:
+            The toast namespace.
+        """
+        self.register_component_warning("progress")
+        return progress
+
+    @staticmethod
+    def register_component_warning(component_name: str):
+        """Add component to emitted warnings and throw a warning if it
+        doesn't exist.
+
+        Args:
+             component_name: name of the component.
+        """
+        if component_name not in _EMITTED_PROMOTION_WARNINGS:
+            _EMITTED_PROMOTION_WARNINGS.add(component_name)
+            warn(f"`rx._x.{component_name}` was promoted to `rx.{component_name}`.")
+
 
 _x = ExperimentalNamespace(
     asset=asset,
     client_state=ClientStateVar.create,
     hooks=hooks,
-    vars=vars,
     layout=layout,
-    progress=progress,
     PropsBase=PropsBase,
     run_in_thread=run_in_thread,
 )

reflex/experimental/client_state.py

@@ -4,12 +4,17 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import Any, Callable, Optional, Type, Union
+from typing import Any, Callable, Union
 
 from reflex import constants
 from reflex.event import EventChain, EventHandler, EventSpec, call_script
+from reflex.ivars.base import ImmutableVar, LiteralVar
+from reflex.ivars.function import FunctionVar
 from reflex.utils.imports import ImportVar
-from reflex.vars import Var, VarData, get_unique_variable_name
+from reflex.vars import (
+    VarData,
+    get_unique_variable_name,
+)
 
 NoValue = object()
 
@@ -33,36 +38,19 @@ def _client_state_ref(var_name: str) -> str:
 
 @dataclasses.dataclass(
     eq=False,
+    frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class ClientStateVar(Var):
+class ClientStateVar(ImmutableVar):
     """A Var that exists on the client via useState."""
 
-    # The name of the var.
-    _var_name: str = dataclasses.field()
-
     # Track the names of the getters and setters
-    _setter_name: str = dataclasses.field()
-    _getter_name: str = dataclasses.field()
+    _setter_name: str = dataclasses.field(default="")
+    _getter_name: str = dataclasses.field(default="")
 
     # Whether to add the var and setter to the global `refs` object for use in any Component.
     _global_ref: bool = dataclasses.field(default=True)
 
-    # The type of the var.
-    _var_type: Type = dataclasses.field(default=Any)
-
-    # Whether this is a local javascript variable.
-    _var_is_local: bool = dataclasses.field(default=False)
-
-    # Whether the var is a string literal.
-    _var_is_string: bool = dataclasses.field(default=False)
-
-    # _var_full_name should be prefixed with _var_state
-    _var_full_name_needs_state_prefix: bool = dataclasses.field(default=False)
-
-    # Extra metadata associated with the Var
-    _var_data: Optional[VarData] = dataclasses.field(default=None)
-
     def __hash__(self) -> int:
         """Define a hash function for a var.
 
@@ -109,17 +97,16 @@ class ClientStateVar(Var):
             var_name = get_unique_variable_name()
         assert isinstance(var_name, str), "var_name must be a string."
         if default is NoValue:
-            default_var = Var.create_safe("", _var_is_local=False, _var_is_string=False)
-        elif not isinstance(default, Var):
-            default_var = Var.create_safe(
-                default,
-                _var_is_string=isinstance(default, str),
+            default_var = ImmutableVar.create_safe(
+                "", _var_is_local=False, _var_is_string=False
             )
+        elif not isinstance(default, ImmutableVar):
+            default_var = LiteralVar.create(default)
         else:
             default_var = default
         setter_name = f"set{var_name.capitalize()}"
         hooks = {
-            f"const [{var_name}, {setter_name}] = useState({default_var._var_name_unwrapped})": None,
+            f"const [{var_name}, {setter_name}] = useState({str(default_var)})": None,
         }
         imports = {
             "react": [ImportVar(tag="useState")],
@@ -133,12 +120,10 @@ class ClientStateVar(Var):
             _setter_name=setter_name,
             _getter_name=var_name,
             _global_ref=global_ref,
-            _var_is_local=False,
-            _var_is_string=False,
             _var_type=default_var._var_type,
             _var_data=VarData.merge(
                 default_var._var_data,
-                VarData(  # type: ignore
+                VarData(
                     hooks=hooks,
                     imports=imports,
                 ),
@@ -146,7 +131,7 @@ class ClientStateVar(Var):
         )
 
     @property
-    def value(self) -> Var:
+    def value(self) -> ImmutableVar:
         """Get a placeholder for the Var.
 
         This property can only be rendered on the frontend.
@@ -157,12 +142,10 @@ class ClientStateVar(Var):
             an accessor for the client state variable.
         """
         return (
-            Var.create_safe(
+            ImmutableVar.create_safe(
                 _client_state_ref(self._getter_name)
                 if self._global_ref
-                else self._getter_name,
-                _var_is_local=False,
-                _var_is_string=False,
+                else self._getter_name
             )
             .to(self._var_type)
             ._replace(
@@ -172,7 +155,7 @@ class ClientStateVar(Var):
             )
         )
 
-    def set_value(self, value: Any = NoValue) -> Var:
+    def set_value(self, value: Any = NoValue) -> ImmutableVar:
         """Set the value of the client state variable.
 
         This property can only be attached to a frontend event trigger.
@@ -191,29 +174,22 @@ class ClientStateVar(Var):
             else self._setter_name
         )
         if value is not NoValue:
+            import re
+
             # This is a hack to make it work like an EventSpec taking an arg
-            value = Var.create_safe(value, _var_is_string=isinstance(value, str))
-            if not value._var_is_string and value._var_full_name.startswith("_"):
-                arg = value._var_name_unwrapped.partition(".")[0]
-            else:
-                arg = ""
-            setter = f"({arg}) => {setter}({value._var_name_unwrapped})"
-        return (
-            Var.create_safe(
-                setter,
-                _var_is_local=False,
-                _var_is_string=False,
-            )
-            .to(EventChain)
-            ._replace(
-                merge_var_data=VarData(  # type: ignore
-                    imports=_refs_import if self._global_ref else {}
-                )
-            )
-        )
+            value_str = str(LiteralVar.create(value))
+
+            # remove patterns of ["*"] from the value_str using regex
+            arg = re.sub(r"\[\".*\"\]", "", value_str)
+
+            setter = f"({arg}) => {setter}({str(value)})"
+        return ImmutableVar(
+            _var_name=setter,
+            _var_data=VarData(imports=_refs_import if self._global_ref else {}),
+        ).to(FunctionVar, EventChain)
 
     @property
-    def set(self) -> Var:
+    def set(self) -> ImmutableVar:
         """Set the value of the client state variable.
 
         This property can only be attached to a frontend event trigger.

reflex/experimental/hooks.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 
+from reflex.ivars.base import ImmutableVar
 from reflex.utils.imports import ImportVar
-from reflex.vars import Var, VarData
+from reflex.vars import VarData
 
 
 def _compose_react_imports(tags: list[str]) -> dict[str, list[ImportVar]]:
     return {"react": [ImportVar(tag=tag) for tag in tags]}
 
 
-def const(name, value) -> Var:
+def const(name, value) -> ImmutableVar:
     """Create a constant Var.
 
     Args:
@@ -21,13 +22,11 @@ def const(name, value) -> Var:
         The constant Var.
     """
     if isinstance(name, list):
-        return Var.create_safe(
-            f"const [{', '.join(name)}] = {value}", _var_is_string=False
-        )
-    return Var.create_safe(f"const {name} = {value}", _var_is_string=False)
+        return ImmutableVar.create_safe(f"const [{', '.join(name)}] = {value}")
+    return ImmutableVar.create_safe(f"const {name} = {value}")
 
 
-def useCallback(func, deps) -> Var:
+def useCallback(func, deps) -> ImmutableVar:
     """Create a useCallback hook with a function and dependencies.
 
     Args:
@@ -37,14 +36,13 @@ def useCallback(func, deps) -> Var:
     Returns:
         The useCallback hook.
     """
-    return Var.create_safe(
+    return ImmutableVar.create_safe(
         f"useCallback({func}, {deps})" if deps else f"useCallback({func})",
-        _var_is_string=False,
         _var_data=VarData(imports=_compose_react_imports(["useCallback"])),
     )
 
 
-def useContext(context) -> Var:
+def useContext(context) -> ImmutableVar:
     """Create a useContext hook with a context.
 
     Args:
@@ -53,14 +51,13 @@ def useContext(context) -> Var:
     Returns:
         The useContext hook.
     """
-    return Var.create_safe(
+    return ImmutableVar.create_safe(
         f"useContext({context})",
-        _var_is_string=False,
         _var_data=VarData(imports=_compose_react_imports(["useContext"])),
     )
 
 
-def useRef(default) -> Var:
+def useRef(default) -> ImmutableVar:
     """Create a useRef hook with a default value.
 
     Args:
@@ -69,14 +66,13 @@ def useRef(default) -> Var:
     Returns:
         The useRef hook.
     """
-    return Var.create_safe(
+    return ImmutableVar.create_safe(
         f"useRef({default})",
-        _var_is_string=False,
         _var_data=VarData(imports=_compose_react_imports(["useRef"])),
     )
 
 
-def useState(var_name, default=None) -> Var:
+def useState(var_name, default=None) -> ImmutableVar:
     """Create a useState hook with a variable name and setter name.
 
     Args:
@@ -88,9 +84,8 @@ def useState(var_name, default=None) -> Var:
     """
     return const(
         [var_name, f"set{var_name.capitalize()}"],
-        Var.create_safe(
+        ImmutableVar.create_safe(
             f"useState({default})",
-            _var_is_string=False,
             _var_data=VarData(imports=_compose_react_imports(["useState"])),
         ),
     )