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

reflex/components/tags/iter_tag.py

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

reflex/components/tags/match_tag.py

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

reflex/components/tags/tag.py

@@ -2,23 +2,22 @@
 
 from __future__ import annotations
 
-import dataclasses
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, 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
 
 
-@dataclasses.dataclass()
-class Tag:
+class Tag(Base):
     """A React tag."""
 
     # The name of the tag.
     name: str = ""
 
     # The props of the tag.
-    props: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    props: Dict[str, Any] = {}
 
     # The inner contents of the tag.
     contents: str = ""
@@ -27,18 +26,25 @@ class Tag:
     args: Optional[Tuple[str, ...]] = None
 
     # Special props that aren't key value pairs.
-    special_props: List[Var] = dataclasses.field(default_factory=list)
+    special_props: Set[ImmutableVar] = set()
 
     # The children components.
-    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()},
-        )
+    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)
 
     def format_props(self) -> List:
         """Format the tag's props.
@@ -48,29 +54,6 @@ class Tag:
         """
         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.
 
@@ -109,7 +92,7 @@ class Tag:
         return self
 
     @staticmethod
-    def is_valid_prop(prop: Optional[Var]) -> bool:
+    def is_valid_prop(prop: Optional[ImmutableVar]) -> bool:
         """Check if the prop is valid.
 
         Args:

reflex/custom_components/custom_components.py

@@ -65,9 +65,7 @@ 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,
-                reflex_version=constants.Reflex.VERSION,
+                module_name=module_name, package_name=package_name
             )
         )
 

reflex/event.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import dataclasses
 import inspect
 import types
 import urllib.parse
@@ -19,13 +18,14 @@ 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 VarData
-from reflex.vars.base import LiteralVar, Var
-from reflex.vars.function import FunctionStringVar, FunctionVar
-from reflex.vars.object import ObjectVar
+from reflex.vars import Var, VarData
 
 try:
     from typing import Annotated
@@ -33,11 +33,7 @@ except ImportError:
     from typing_extensions import Annotated
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
-class Event:
+class Event(Base):
     """An event that describes any state change in the app."""
 
     # The token to specify the client that the event is for.
@@ -47,10 +43,10 @@ class Event:
     name: str
 
     # The routing data where event occurred
-    router_data: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    router_data: Dict[str, Any] = {}
 
     # The event payload.
-    payload: Dict[str, Any] = dataclasses.field(default_factory=dict)
+    payload: Dict[str, Any] = {}
 
     @property
     def substate_token(self) -> str:
@@ -85,15 +81,11 @@ def background(fn):
     return fn
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
-class EventActionsMixin:
+class EventActionsMixin(Base):
     """Mixin for DOM event actions."""
 
     # Whether to `preventDefault` or `stopPropagation` on the event.
-    event_actions: Dict[str, Union[bool, int]] = dataclasses.field(default_factory=dict)
+    event_actions: Dict[str, Union[bool, int]] = {}
 
     @property
     def stop_propagation(self):
@@ -102,9 +94,8 @@ class EventActionsMixin:
         Returns:
             New EventHandler-like with stopPropagation set to True.
         """
-        return dataclasses.replace(
-            self,
-            event_actions={"stopPropagation": True, **self.event_actions},
+        return self.copy(
+            update={"event_actions": {"stopPropagation": True, **self.event_actions}},
         )
 
     @property
@@ -114,9 +105,8 @@ class EventActionsMixin:
         Returns:
             New EventHandler-like with preventDefault set to True.
         """
-        return dataclasses.replace(
-            self,
-            event_actions={"preventDefault": True, **self.event_actions},
+        return self.copy(
+            update={"event_actions": {"preventDefault": True, **self.event_actions}},
         )
 
     def throttle(self, limit_ms: int):
@@ -128,9 +118,8 @@ class EventActionsMixin:
         Returns:
             New EventHandler-like with throttle set to limit_ms.
         """
-        return dataclasses.replace(
-            self,
-            event_actions={"throttle": limit_ms, **self.event_actions},
+        return self.copy(
+            update={"event_actions": {"throttle": limit_ms, **self.event_actions}},
         )
 
     def debounce(self, delay_ms: int):
@@ -142,25 +131,26 @@ class EventActionsMixin:
         Returns:
             New EventHandler-like with debounce set to delay_ms.
         """
-        return dataclasses.replace(
-            self,
-            event_actions={"debounce": delay_ms, **self.event_actions},
+        return self.copy(
+            update={"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 = dataclasses.field(default=None)
+    fn: Any
 
     # 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 = dataclasses.field(default="")
+    state_full_name: str = ""
+
+    class Config:
+        """The Pydantic config."""
+
+        # Needed to allow serialization of Callable.
+        frozen = True
 
     @classmethod
     def __class_getitem__(cls, args_spec: str) -> Annotated:
@@ -201,7 +191,7 @@ class EventHandler(EventActionsMixin):
 
         # Get the function args.
         fn_args = inspect.getfullargspec(self.fn).args[1:]
-        fn_args = (Var(_js_expr=arg) for arg in fn_args)
+        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
@@ -225,10 +215,6 @@ class EventHandler(EventActionsMixin):
         )
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
 class EventSpec(EventActionsMixin):
     """An event specification.
 
@@ -237,37 +223,23 @@ class EventSpec(EventActionsMixin):
     """
 
     # The event handler.
-    handler: EventHandler = dataclasses.field(default=None)  # type: ignore
+    handler: EventHandler
 
     # The handler on the client to process event.
-    client_handler_name: str = dataclasses.field(default="")
+    client_handler_name: str = ""
 
     # The arguments to pass to the function.
-    args: Tuple[Tuple[Var, Var], ...] = dataclasses.field(default_factory=tuple)
+    args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...] = ()
 
-    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.
+    class Config:
+        """The Pydantic config."""
 
-        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:
+        # Required to allow tuple fields.
+        frozen = True
+
+    def with_args(
+        self, args: Tuple[Tuple[ImmutableVar, ImmutableVar], ...]
+    ) -> EventSpec:
         """Copy the event spec, with updated args.
 
         Args:
@@ -283,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:
@@ -299,7 +271,7 @@ class EventSpec(EventActionsMixin):
 
         # Get the remaining unfilled function args.
         fn_args = inspect.getfullargspec(self.handler.fn).args[1 + len(self.args) :]
-        fn_args = (Var(_js_expr=arg) for arg in fn_args)
+        fn_args = (ImmutableVar.create_safe(arg) for arg in fn_args)
 
         # Construct the payload.
         values = []
@@ -314,9 +286,6 @@ class EventSpec(EventActionsMixin):
         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.
 
@@ -336,13 +305,10 @@ class CallableEventSpec(EventSpec):
         if fn is not None:
             default_event_spec = fn()
             super().__init__(
-                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,
+                fn=fn,  # type: ignore
+                **default_event_spec.dict(),
                 **kwargs,
             )
-            object.__setattr__(self, "fn", fn)
         else:
             super().__init__(**kwargs)
 
@@ -366,16 +332,12 @@ 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] = dataclasses.field(default_factory=list)
+    events: List[EventSpec]
 
-    args_spec: Optional[Callable] = dataclasses.field(default=None)
+    args_spec: Optional[Callable]
 
 
 # These chains can be used for their side effects when no other events are desired.
@@ -383,22 +345,14 @@ stop_propagation = EventChain(events=[], args_spec=lambda: []).stop_propagation
 prevent_default = EventChain(events=[], args_spec=lambda: []).prevent_default
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
-class Target:
+class Target(Base):
     """A Javascript event target."""
 
     checked: bool = False
     value: Any = None
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
-class FrontendEvent:
+class FrontendEvent(Base):
     """A Javascript event."""
 
     target: Target = Target()
@@ -406,11 +360,7 @@ class FrontendEvent:
     value: Any = None
 
 
-@dataclasses.dataclass(
-    init=True,
-    frozen=True,
-)
-class FileUpload:
+class FileUpload(Base):
     """Class to represent a file upload."""
 
     upload_id: Optional[str] = None
@@ -445,15 +395,15 @@ class FileUpload:
         upload_id = self.upload_id or DEFAULT_UPLOAD_ID
         spec_args = [
             (
-                Var(_js_expr="files"),
-                Var(
-                    _js_expr="filesById",
+                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(_js_expr="upload_id"),
+                ImmutableVar.create_safe("upload_id"),
                 LiteralVar.create(upload_id),
             ),
         ]
@@ -473,7 +423,7 @@ class FileUpload:
                 )  # 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,
@@ -482,7 +432,7 @@ class FileUpload:
             formatted_chain = str(format.format_prop(on_upload_progress_chain))
             spec_args.append(
                 (
-                    Var(_js_expr="on_upload_progress"),
+                    ImmutableVar.create_safe("on_upload_progress"),
                     FunctionStringVar(
                         formatted_chain.strip("{}"),
                     ).to(FunctionVar, EventChain),
@@ -522,7 +472,7 @@ def server_side(name: str, sig: inspect.Signature, **kwargs) -> EventSpec:
         handler=EventHandler(fn=fn),
         args=tuple(
             (
-                Var(_js_expr=k),
+                ImmutableVar.create_safe(k),
                 LiteralVar.create(v),
             )
             for k, v in kwargs.items()
@@ -728,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.
 
@@ -766,7 +716,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, Var):
+        elif isinstance(data, ImmutableVar):
             # Need to check on the frontend if the Var already looks like a data: URI.
 
             is_data_url = (data.js_type() == "string") & (
@@ -923,13 +873,15 @@ def parse_args_spec(arg_spec: ArgsSpec):
     annotations = get_type_hints(arg_spec)
     return arg_spec(
         *[
-            Var(f"_{l_arg}").to(annotations.get(l_arg, FrontendEvent))
+            ImmutableVar(f"_{l_arg}").to(
+                ObjectVar, annotations.get(l_arg, FrontendEvent)
+            )
             for l_arg in spec.args
         ]
     )
 
 
-def call_event_fn(fn: Callable, arg_spec: 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
@@ -970,7 +922,7 @@ def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | Var:
     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.
@@ -999,7 +951,7 @@ def call_event_fn(fn: Callable, arg_spec: ArgsSpec) -> list[EventSpec] | Var:
 
 def get_handler_args(
     event_spec: EventSpec,
-) -> tuple[tuple[Var, Var], ...]:
+) -> tuple[tuple[ImmutableVar, ImmutableVar], ...]:
     """Get the handler args for the given event spec.
 
     Args:
@@ -1050,7 +1002,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._js_expr: v._decode() for k, v in e.args}  # type: ignore
+        payload = {k._var_name: v._decode() for k, v in e.args}  # type: ignore
 
         # Filter router_data to reduce payload size
         event_router_data = {