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

reflex/components/tags/cond_tag.py

@@ -1,19 +1,21 @@
 """Tag to conditionally render components."""
 
+import dataclasses
 from typing import Any, Dict, Optional
 
 from reflex.components.tags.tag import Tag
-from reflex.vars import Var
+from reflex.vars.base import Var
 
 
+@dataclasses.dataclass()
 class CondTag(Tag):
     """A conditional tag."""
 
     # The condition to determine which component to render.
-    cond: Var[Any]
+    cond: Var[Any] = dataclasses.field(default_factory=lambda: Var.create(True))
 
     # The code to render if the condition is true.
-    true_value: Dict
+    true_value: Dict = dataclasses.field(default_factory=dict)
 
     # The code to render if the condition is false.
-    false_value: Optional[Dict]
+    false_value: Optional[Dict] = None

reflex/components/tags/iter_tag.py

@@ -2,30 +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.vars import BaseVar, 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.
@@ -33,15 +46,16 @@ class IterTag(Tag):
         Returns:
             The type of the iterable var.
         """
+        iterable = self.iterable
         try:
-            if self.iterable._var_type.mro()[0] == dict:
+            if iterable._var_type.mro()[0] == dict:
                 # Arg is a tuple of (key, value).
-                return Tuple[get_args(self.iterable._var_type)]  # type: ignore
-            elif self.iterable._var_type.mro()[0] == tuple:
+                return Tuple[get_args(iterable._var_type)]  # type: ignore
+            elif iterable._var_type.mro()[0] == tuple:
                 # Arg is a union of any possible values in the tuple.
-                return Union[get_args(self.iterable._var_type)]  # type: ignore
+                return Union[get_args(iterable._var_type)]  # type: ignore
             else:
-                return get_args(self.iterable._var_type)[0]
+                return get_args(iterable._var_type)[0]
         except Exception:
             return Any
 
@@ -53,10 +67,10 @@ class IterTag(Tag):
         Returns:
             The index var.
         """
-        return BaseVar(
-            _var_name=self.index_var_name,
+        return Var(
+            _js_expr=self.index_var_name,
             _var_type=int,
-        )
+        ).guess_type()
 
     def get_arg_var(self) -> Var:
         """Get the arg var for the tag (with curly braces).
@@ -66,10 +80,10 @@ class IterTag(Tag):
         Returns:
             The arg var.
         """
-        return BaseVar(
-            _var_name=self.arg_var_name,
+        return Var(
+            _js_expr=self.arg_var_name,
             _var_type=self.get_iterable_var_type(),
-        )
+        ).guess_type()
 
     def get_index_var_arg(self) -> Var:
         """Get the index var for the tag (without curly braces).
@@ -79,11 +93,10 @@ class IterTag(Tag):
         Returns:
             The index var.
         """
-        return BaseVar(
-            _var_name=self.index_var_name,
+        return Var(
+            _js_expr=self.index_var_name,
             _var_type=int,
-            _var_is_local=True,
-        )
+        ).guess_type()
 
     def get_arg_var_arg(self) -> Var:
         """Get the arg var for the tag (without curly braces).
@@ -93,11 +106,10 @@ class IterTag(Tag):
         Returns:
             The arg var.
         """
-        return BaseVar(
-            _var_name=self.arg_var_name,
+        return Var(
+            _js_expr=self.arg_var_name,
             _var_type=self.get_iterable_var_type(),
-            _var_is_local=True,
-        )
+        ).guess_type()
 
     def render_component(self) -> Component:
         """Render the component.

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.utils import format, types
-from reflex.vars import Var
+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[Var] = 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: Var.create(value, _var_is_string=False)
-                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.
 
@@ -63,14 +80,12 @@ class Tag(Base):
         Returns:
             The tag with the props added.
         """
-        from reflex.components.core.colors import Color
-
         self.props.update(
             {
-                format.to_camel_case(name, allow_hyphens=True): prop
-                if types._isinstance(prop, Union[EventChain, dict])
-                else Var.create(
-                    prop, _var_is_string=isinstance(prop, Color)
+                format.to_camel_case(name, allow_hyphens=True): (
+                    prop
+                    if types._isinstance(prop, Union[EventChain, dict])
+                    else LiteralVar.create(prop)
                 )  # rx.color is always a string
                 for name, prop in kwargs.items()
                 if self.is_valid_prop(prop)

reflex/constants/base.py

@@ -45,6 +45,8 @@ class Dirs(SimpleNamespace):
     REFLEX_JSON = "reflex.json"
     # The name of the postcss config file.
     POSTCSS_JS = "postcss.config.js"
+    # The name of the states directory.
+    STATES = "states"
 
 
 class Reflex(SimpleNamespace):
@@ -103,7 +105,7 @@ class Templates(SimpleNamespace):
 
     # The reflex.build backend host
     REFLEX_BUILD_BACKEND = os.environ.get(
-        "REFLEX_BUILD_BACKEND", "https://rxh-prod-flexgen.fly.dev"
+        "REFLEX_BUILD_BACKEND", "https://flexgen-prod-flexgen.fly.dev"
     )
 
     # The URL to redirect to reflex.build

reflex/constants/event.py

@@ -11,6 +11,7 @@ class Endpoint(Enum):
     EVENT = "_event"
     UPLOAD = "_upload"
     AUTH_CODESPACE = "auth-codespace"
+    HEALTH = "_health"
 
     def __str__(self) -> str:
         """Get the string representation of the endpoint.

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,
             )
         )