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

reflex/components/tags/iter_tag.py

@@ -2,31 +2,43 @@
 
 from __future__ import annotations
 
+import dataclasses
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, List, Tuple, Type, Union, get_args
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Iterable,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+)
 
 from reflex.components.tags.tag import Tag
-from reflex.ivars.base import ImmutableVar
-from reflex.vars import Var
+from reflex.vars import LiteralArrayVar, Var, get_unique_variable_name
 
 if TYPE_CHECKING:
     from reflex.components.component import Component
 
 
+@dataclasses.dataclass()
 class IterTag(Tag):
     """An iterator tag."""
 
     # The var to iterate over.
-    iterable: Var[List]
+    iterable: Var[Iterable] = dataclasses.field(
+        default_factory=lambda: LiteralArrayVar.create([])
+    )
 
     # The component render function for each item in the iterable.
-    render_fn: Callable
+    render_fn: Callable = dataclasses.field(default_factory=lambda: lambda x: x)
 
     # The name of the arg var.
-    arg_var_name: str
+    arg_var_name: str = dataclasses.field(default_factory=get_unique_variable_name)
 
     # The name of the index var.
-    index_var_name: str
+    index_var_name: str = dataclasses.field(default_factory=get_unique_variable_name)
 
     def get_iterable_var_type(self) -> Type:
         """Get the type of the iterable var.
@@ -34,7 +46,7 @@ class IterTag(Tag):
         Returns:
             The type of the iterable var.
         """
-        iterable = self.iterable.upcast()
+        iterable = self.iterable
         try:
             if iterable._var_type.mro()[0] == dict:
                 # Arg is a tuple of (key, value).
@@ -55,8 +67,8 @@ class IterTag(Tag):
         Returns:
             The index var.
         """
-        return ImmutableVar(
-            _var_name=self.index_var_name,
+        return Var(
+            _js_expr=self.index_var_name,
             _var_type=int,
         ).guess_type()
 
@@ -68,8 +80,8 @@ class IterTag(Tag):
         Returns:
             The arg var.
         """
-        return ImmutableVar(
-            _var_name=self.arg_var_name,
+        return Var(
+            _js_expr=self.arg_var_name,
             _var_type=self.get_iterable_var_type(),
         ).guess_type()
 
@@ -81,8 +93,8 @@ class IterTag(Tag):
         Returns:
             The index var.
         """
-        return ImmutableVar(
-            _var_name=self.index_var_name,
+        return Var(
+            _js_expr=self.index_var_name,
             _var_type=int,
         ).guess_type()
 
@@ -94,8 +106,8 @@ class IterTag(Tag):
         Returns:
             The arg var.
         """
-        return ImmutableVar(
-            _var_name=self.arg_var_name,
+        return Var(
+            _js_expr=self.arg_var_name,
             _var_type=self.get_iterable_var_type(),
         ).guess_type()
 

reflex/components/tags/match_tag.py

@@ -1,19 +1,21 @@
 """Tag to conditionally match cases."""
 
+import dataclasses
 from typing import Any, List
 
 from reflex.components.tags.tag import Tag
-from reflex.vars import Var
+from reflex.vars.base import Var
 
 
+@dataclasses.dataclass()
 class MatchTag(Tag):
     """A match tag."""
 
     # The condition to determine which case to match.
-    cond: Var[Any]
+    cond: Var[Any] = dataclasses.field(default_factory=lambda: Var.create(True))
 
     # The list of match cases to be matched.
-    match_cases: List[Any]
+    match_cases: List[Any] = dataclasses.field(default_factory=list)
 
     # The catchall case to match.
-    default: Any
+    default: Any = dataclasses.field(default=Var.create(None))

reflex/components/tags/tag.py

@@ -2,22 +2,23 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+import dataclasses
+from typing import Any, Dict, List, Optional, Tuple, Union
 
-from reflex.base import Base
 from reflex.event import EventChain
-from reflex.ivars.base import ImmutableVar, LiteralVar
 from reflex.utils import format, types
+from reflex.vars.base import LiteralVar, Var
 
 
-class Tag(Base):
+@dataclasses.dataclass()
+class Tag:
     """A React tag."""
 
     # The name of the tag.
     name: str = ""
 
     # The props of the tag.
-    props: Dict[str, Any] = {}
+    props: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
     # The inner contents of the tag.
     contents: str = ""
@@ -26,25 +27,18 @@ class Tag(Base):
     args: Optional[Tuple[str, ...]] = None
 
     # Special props that aren't key value pairs.
-    special_props: Set[ImmutableVar] = set()
+    special_props: List[Var] = dataclasses.field(default_factory=list)
 
     # The children components.
-    children: List[Any] = []
-
-    def __init__(self, *args, **kwargs):
-        """Initialize the tag.
-
-        Args:
-            *args: Args to initialize the tag.
-            **kwargs: Kwargs to initialize the tag.
-        """
-        # Convert any props to vars.
-        if "props" in kwargs:
-            kwargs["props"] = {
-                name: LiteralVar.create(value)
-                for name, value in kwargs["props"].items()
-            }
-        super().__init__(*args, **kwargs)
+    children: List[Any] = dataclasses.field(default_factory=list)
+
+    def __post_init__(self):
+        """Post initialize the tag."""
+        object.__setattr__(
+            self,
+            "props",
+            {name: LiteralVar.create(value) for name, value in self.props.items()},
+        )
 
     def format_props(self) -> List:
         """Format the tag's props.
@@ -54,6 +48,29 @@ class Tag(Base):
         """
         return format.format_props(*self.special_props, **self.props)
 
+    def set(self, **kwargs: Any):
+        """Set the tag's fields.
+
+        Args:
+            kwargs: The fields to set.
+
+        Returns:
+            The tag with the fields
+        """
+        for name, value in kwargs.items():
+            setattr(self, name, value)
+
+        return self
+
+    def __iter__(self):
+        """Iterate over the tag's fields.
+
+        Yields:
+            Tuple[str, Any]: The field name and value.
+        """
+        for field in dataclasses.fields(self):
+            yield field.name, getattr(self, field.name)
+
     def add_props(self, **kwargs: Optional[Any]) -> Tag:
         """Add props to the tag.
 
@@ -92,7 +109,7 @@ class Tag(Base):
         return self
 
     @staticmethod
-    def is_valid_prop(prop: Optional[ImmutableVar]) -> bool:
+    def is_valid_prop(prop: Optional[Var]) -> bool:
         """Check if the prop is valid.
 
         Args:

reflex/custom_components/custom_components.py

@@ -65,7 +65,9 @@ def _create_package_config(module_name: str, package_name: str):
     with open(CustomComponents.PYPROJECT_TOML, "w") as f:
         f.write(
             templates.CUSTOM_COMPONENTS_PYPROJECT_TOML.render(
-                module_name=module_name, package_name=package_name
+                module_name=module_name,
+                package_name=package_name,
+                reflex_version=constants.Reflex.VERSION,
             )
         )
 

reflex/event.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import inspect
 import types
 import urllib.parse
@@ -18,14 +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 Var, VarData
+from reflex.vars import VarData
+from reflex.vars.base import LiteralVar, Var
+from reflex.vars.function import FunctionStringVar, FunctionVar
+from reflex.vars.object import ObjectVar
 
 try:
     from typing import Annotated
@@ -33,7 +33,11 @@ except ImportError:
     from typing_extensions import Annotated
 
 
-class Event(Base):
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
+class Event:
     """An event that describes any state change in the app."""
 
     # The token to specify the client that the event is for.
@@ -43,10 +47,10 @@ class Event(Base):
     name: str
 
     # The routing data where event occurred
-    router_data: Dict[str, Any] = {}
+    router_data: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
     # The event payload.
-    payload: Dict[str, Any] = {}
+    payload: Dict[str, Any] = dataclasses.field(default_factory=dict)
 
     @property
     def substate_token(self) -> str:
@@ -81,11 +85,15 @@ def background(fn):
     return fn
 
 
-class EventActionsMixin(Base):
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
+class EventActionsMixin:
     """Mixin for DOM event actions."""
 
     # Whether to `preventDefault` or `stopPropagation` on the event.
-    event_actions: Dict[str, Union[bool, int]] = {}
+    event_actions: Dict[str, Union[bool, int]] = dataclasses.field(default_factory=dict)
 
     @property
     def stop_propagation(self):
@@ -94,8 +102,9 @@ class EventActionsMixin(Base):
         Returns:
             New EventHandler-like with stopPropagation set to True.
         """
-        return self.copy(
-            update={"event_actions": {"stopPropagation": True, **self.event_actions}},
+        return dataclasses.replace(
+            self,
+            event_actions={"stopPropagation": True, **self.event_actions},
         )
 
     @property
@@ -105,8 +114,9 @@ class EventActionsMixin(Base):
         Returns:
             New EventHandler-like with preventDefault set to True.
         """
-        return self.copy(
-            update={"event_actions": {"preventDefault": True, **self.event_actions}},
+        return dataclasses.replace(
+            self,
+            event_actions={"preventDefault": True, **self.event_actions},
         )
 
     def throttle(self, limit_ms: int):
@@ -118,8 +128,9 @@ class EventActionsMixin(Base):
         Returns:
             New EventHandler-like with throttle set to limit_ms.
         """
-        return self.copy(
-            update={"event_actions": {"throttle": limit_ms, **self.event_actions}},
+        return dataclasses.replace(
+            self,
+            event_actions={"throttle": limit_ms, **self.event_actions},
         )
 
     def debounce(self, delay_ms: int):
@@ -131,26 +142,25 @@ class EventActionsMixin(Base):
         Returns:
             New EventHandler-like with debounce set to delay_ms.
         """
-        return self.copy(
-            update={"event_actions": {"debounce": delay_ms, **self.event_actions}},
+        return dataclasses.replace(
+            self,
+            event_actions={"debounce": delay_ms, **self.event_actions},
         )
 
 
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
 class EventHandler(EventActionsMixin):
     """An event handler responds to an event to update the state."""
 
     # The function to call in response to the event.
-    fn: Any
+    fn: Any = dataclasses.field(default=None)
 
     # The full name of the state class this event handler is attached to.
     # Empty string means this event handler is a server side event.
-    state_full_name: str = ""
-
-    class Config:
-        """The Pydantic config."""
-
-        # Needed to allow serialization of Callable.
-        frozen = True
+    state_full_name: str = dataclasses.field(default="")
 
     @classmethod
     def __class_getitem__(cls, args_spec: str) -> Annotated:
@@ -191,7 +201,7 @@ class EventHandler(EventActionsMixin):
 
         # Get the function args.
         fn_args = inspect.getfullargspec(self.fn).args[1:]
-        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
+        fn_args = (Var(_js_expr=arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
@@ -207,7 +217,7 @@ class EventHandler(EventActionsMixin):
                 raise EventHandlerTypeError(
                     f"Arguments to event handlers must be Vars or JSON-serializable. Got {arg} of type {type(arg)}."
                 ) from e
-        payload = tuple(zip(fn_args, values))
+        payload = tuple(zip(fn_args, values, strict=False))
 
         # Return the event spec.
         return EventSpec(
@@ -215,6 +225,10 @@ class EventHandler(EventActionsMixin):
         )
 
 
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
 class EventSpec(EventActionsMixin):
     """An event specification.
 
@@ -223,23 +237,37 @@ class EventSpec(EventActionsMixin):
     """
 
     # The event handler.
-    handler: EventHandler
+    handler: EventHandler = dataclasses.field(default=None)  # type: ignore
 
     # The handler on the client to process event.
-    client_handler_name: str = ""
+    client_handler_name: str = dataclasses.field(default="")
 
     # The arguments to pass to the function.
-    args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...] = ()
+    args: Tuple[Tuple[Var, Var], ...] = dataclasses.field(default_factory=tuple)
 
-    class Config:
-        """The Pydantic config."""
+    def __init__(
+        self,
+        handler: EventHandler,
+        event_actions: Dict[str, Union[bool, int]] | None = None,
+        client_handler_name: str = "",
+        args: Tuple[Tuple[Var, Var], ...] = tuple(),
+    ):
+        """Initialize an EventSpec.
 
-        # Required to allow tuple fields.
-        frozen = True
-
-    def with_args(
-        self, args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...]
-    ) -> EventSpec:
+        Args:
+            event_actions: The event actions.
+            handler: The event handler.
+            client_handler_name: The client handler name.
+            args: The arguments to pass to the function.
+        """
+        if event_actions is None:
+            event_actions = {}
+        object.__setattr__(self, "event_actions", event_actions)
+        object.__setattr__(self, "handler", handler)
+        object.__setattr__(self, "client_handler_name", client_handler_name)
+        object.__setattr__(self, "args", args or tuple())
+
+    def with_args(self, args: Tuple[Tuple[Var, Var], ...]) -> EventSpec:
         """Copy the event spec, with updated args.
 
         Args:
@@ -255,7 +283,7 @@ class EventSpec(EventActionsMixin):
             event_actions=self.event_actions.copy(),
         )
 
-    def add_args(self, *args: ImmutableVar) -> EventSpec:
+    def add_args(self, *args: Var) -> EventSpec:
         """Add arguments to the event spec.
 
         Args:
@@ -271,7 +299,7 @@ class EventSpec(EventActionsMixin):
 
         # Get the remaining unfilled function args.
         fn_args = inspect.getfullargspec(self.handler.fn).args[1 + len(self.args) :]
-        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
+        fn_args = (Var(_js_expr=arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
@@ -282,10 +310,13 @@ class EventSpec(EventActionsMixin):
                 raise EventHandlerTypeError(
                     f"Arguments to event handlers must be Vars or JSON-serializable. Got {arg} of type {type(arg)}."
                 ) from e
-        new_payload = tuple(zip(fn_args, values))
+        new_payload = tuple(zip(fn_args, values, strict=False))
         return self.with_args(self.args + new_payload)
 
 
+@dataclasses.dataclass(
+    frozen=True,
+)
 class CallableEventSpec(EventSpec):
     """Decorate an EventSpec-returning function to act as both a EventSpec and a function.
 
@@ -305,10 +336,13 @@ class CallableEventSpec(EventSpec):
         if fn is not None:
             default_event_spec = fn()
             super().__init__(
-                fn=fn,  # type: ignore
-                **default_event_spec.dict(),
+                event_actions=default_event_spec.event_actions,
+                client_handler_name=default_event_spec.client_handler_name,
+                args=default_event_spec.args,
+                handler=default_event_spec.handler,
                 **kwargs,
             )
+            object.__setattr__(self, "fn", fn)
         else:
             super().__init__(**kwargs)
 
@@ -332,12 +366,16 @@ class CallableEventSpec(EventSpec):
         return self.fn(*args, **kwargs)
 
 
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
 class EventChain(EventActionsMixin):
     """Container for a chain of events that will be executed in order."""
 
-    events: List[EventSpec]
+    events: List[EventSpec] = dataclasses.field(default_factory=list)
 
-    args_spec: Optional[Callable]
+    args_spec: Optional[Callable] = dataclasses.field(default=None)
 
 
 # These chains can be used for their side effects when no other events are desired.
@@ -345,14 +383,22 @@ stop_propagation = EventChain(events=[], args_spec=lambda: []).stop_propagation
 prevent_default = EventChain(events=[], args_spec=lambda: []).prevent_default
 
 
-class Target(Base):
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
+class Target:
     """A Javascript event target."""
 
     checked: bool = False
     value: Any = None
 
 
-class FrontendEvent(Base):
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
+class FrontendEvent:
     """A Javascript event."""
 
     target: Target = Target()
@@ -360,7 +406,11 @@ class FrontendEvent(Base):
     value: Any = None
 
 
-class FileUpload(Base):
+@dataclasses.dataclass(
+    init=True,
+    frozen=True,
+)
+class FileUpload:
     """Class to represent a file upload."""
 
     upload_id: Optional[str] = None
@@ -395,15 +445,15 @@ class FileUpload(Base):
         upload_id = self.upload_id or DEFAULT_UPLOAD_ID
         spec_args = [
             (
-                ImmutableVar.create_safe("files"),
-                ImmutableVar(
-                    _var_name="filesById",
+                Var(_js_expr="files"),
+                Var(
+                    _js_expr="filesById",
                     _var_type=Dict[str, Any],
                     _var_data=VarData.merge(upload_files_context_var_data),
                 ).to(ObjectVar)[LiteralVar.create(upload_id)],
             ),
             (
-                ImmutableVar.create_safe("upload_id"),
+                Var(_js_expr="upload_id"),
                 LiteralVar.create(upload_id),
             ),
         ]
@@ -423,7 +473,7 @@ class FileUpload(Base):
                 )  # type: ignore
             else:
                 raise ValueError(f"{on_upload_progress} is not a valid event handler.")
-            if isinstance(events, ImmutableVar):
+            if isinstance(events, Var):
                 raise ValueError(f"{on_upload_progress} cannot return a var {events}.")
             on_upload_progress_chain = EventChain(
                 events=events,
@@ -432,7 +482,7 @@ class FileUpload(Base):
             formatted_chain = str(format.format_prop(on_upload_progress_chain))
             spec_args.append(
                 (
-                    ImmutableVar.create_safe("on_upload_progress"),
+                    Var(_js_expr="on_upload_progress"),
                     FunctionStringVar(
                         formatted_chain.strip("{}"),
                     ).to(FunctionVar, EventChain),
@@ -472,7 +522,7 @@ def server_side(name: str, sig: inspect.Signature, **kwargs) -> EventSpec:
         handler=EventHandler(fn=fn),
         args=tuple(
             (
-                ImmutableVar.create_safe(k),
+                Var(_js_expr=k),
                 LiteralVar.create(v),
             )
             for k, v in kwargs.items()
@@ -678,9 +728,9 @@ def set_clipboard(content: str) -> EventSpec:
 
 
 def download(
-    url: str | ImmutableVar | None = None,
-    filename: Optional[str | ImmutableVar] = None,
-    data: str | bytes | ImmutableVar | None = None,
+    url: str | Var | None = None,
+    filename: Optional[str | Var] = None,
+    data: str | bytes | Var | None = None,
 ) -> EventSpec:
     """Download the file at a given path or with the specified data.
 
@@ -716,7 +766,7 @@ 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, ImmutableVar):
+        elif isinstance(data, Var):
             # Need to check on the frontend if the Var already looks like a data: URI.
 
             is_data_url = (data.js_type() == "string") & (
@@ -873,15 +923,13 @@ def parse_args_spec(arg_spec: ArgsSpec):
     annotations = get_type_hints(arg_spec)
     return arg_spec(
         *[
-            ImmutableVar(f"_{l_arg}").to(
-                ObjectVar, annotations.get(l_arg, FrontendEvent)
-            )
+            Var(f"_{l_arg}").to(annotations.get(l_arg, FrontendEvent))
             for l_arg in spec.args
         ]
     )
 
 
-def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | ImmutableVar:
+def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | Var:
     """Call a function to a list of event specs.
 
     The function should return a single EventSpec, a list of EventSpecs, or a
@@ -922,7 +970,7 @@ def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | Immutab
     out = fn(*parsed_args)
 
     # If the function returns a Var, assume it's an EventChain and render it directly.
-    if isinstance(out, ImmutableVar):
+    if isinstance(out, Var):
         return out
 
     # Convert the output to a list.
@@ -951,7 +999,7 @@ def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | Immutab
 
 def get_handler_args(
     event_spec: EventSpec,
-) -> tuple[tuple[ImmutableVar, ImmutableVar], ...]:
+) -> tuple[tuple[Var, Var], ...]:
     """Get the handler args for the given event spec.
 
     Args:
@@ -1002,7 +1050,7 @@ def fix_events(
             e = e()
         assert isinstance(e, EventSpec), f"Unexpected event type, {type(e)}."
         name = format.format_event_handler(e.handler)
-        payload = {k._var_name: v._decode() for k, v in e.args}  # type: ignore
+        payload = {k._js_expr: v._decode() for k, v in e.args}  # type: ignore
 
         # Filter router_data to reduce payload size
         event_router_data = {