reflex 0.8.7a1__py3-none-any.whl → 0.8.8a2__py3-none-any.whl

reflex/compiler/utils.py

@@ -8,7 +8,7 @@ import traceback
 from collections.abc import Mapping, Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, TypedDict
 from urllib.parse import urlparse
 
 from reflex import constants
@@ -90,7 +90,13 @@ def validate_imports(import_dict: ParsedImportDict):
                 used_tags[import_name] = lib
 
 
-def compile_imports(import_dict: ParsedImportDict) -> list[dict]:
+class _ImportDict(TypedDict):
+    lib: str
+    default: str
+    rest: list[str]
+
+
+def compile_imports(import_dict: ParsedImportDict) -> list[_ImportDict]:
     """Compile an import dict.
 
     Args:
@@ -104,7 +110,7 @@ def compile_imports(import_dict: ParsedImportDict) -> list[dict]:
     """
     collapsed_import_dict: ParsedImportDict = imports.collapse_imports(import_dict)
     validate_imports(collapsed_import_dict)
-    import_dicts = []
+    import_dicts: list[_ImportDict] = []
     for lib, fields in collapsed_import_dict.items():
         # prevent lib from being rendered on the page if all imports are non rendered kind
         if not any(f.render for f in fields):
@@ -139,7 +145,9 @@ def compile_imports(import_dict: ParsedImportDict) -> list[dict]:
     return import_dicts
 
 
-def get_import_dict(lib: str, default: str = "", rest: list[str] | None = None) -> dict:
+def get_import_dict(
+    lib: str, default: str = "", rest: list[str] | None = None
+) -> _ImportDict:
     """Get dictionary for import template.
 
     Args:
@@ -150,11 +158,11 @@ def get_import_dict(lib: str, default: str = "", rest: list[str] | None = None)
     Returns:
         A dictionary for import template.
     """
-    return {
-        "lib": lib,
-        "default": default,
-        "rest": rest if rest else [],
-    }
+    return _ImportDict(
+        lib=lib,
+        default=default,
+        rest=rest if rest else [],
+    )
 
 
 def save_error(error: Exception) -> str:
@@ -237,23 +245,20 @@ def _compile_client_storage_field(
 
 def _compile_client_storage_recursive(
     state: type[BaseState],
-) -> tuple[dict[str, dict], dict[str, dict], dict[str, dict]]:
+) -> tuple[
+    dict[str, dict[str, Any]], dict[str, dict[str, Any]], dict[str, dict[str, Any]]
+]:
     """Compile the client-side storage for the given state recursively.
 
     Args:
         state: The app state object.
 
     Returns:
-        A tuple of the compiled client-side storage info:
-            (
-                cookies: dict[str, dict],
-                local_storage: dict[str, dict[str, str]]
-                session_storage: dict[str, dict[str, str]]
-            ).
+        A tuple of the compiled client-side storage info: (cookies, local_storage, session_storage).
     """
-    cookies = {}
-    local_storage = {}
-    session_storage = {}
+    cookies: dict[str, dict[str, Any]] = {}
+    local_storage: dict[str, dict[str, Any]] = {}
+    session_storage: dict[str, dict[str, Any]] = {}
     state_name = state.get_full_name()
     for name, field in state.__fields__.items():
         if name in state.inherited_vars:
@@ -261,6 +266,8 @@ def _compile_client_storage_recursive(
             continue
         state_key = f"{state_name}.{name}" + FIELD_MARKER
         field_type, options = _compile_client_storage_field(field)
+        if field_type is None or options is None:
+            continue
         if field_type is Cookie:
             cookies[state_key] = options
         elif field_type is LocalStorage:
@@ -281,7 +288,9 @@ def _compile_client_storage_recursive(
     return cookies, local_storage, session_storage
 
 
-def compile_client_storage(state: type[BaseState]) -> dict[str, dict]:
+def compile_client_storage(
+    state: type[BaseState],
+) -> dict[str, dict[str, dict[str, Any]]]:
     """Compile the client-side storage for the given state.
 
     Args:
@@ -341,7 +350,7 @@ def compile_custom_component(
 def create_document_root(
     head_components: Sequence[Component] | None = None,
     html_lang: str | None = None,
-    html_custom_attrs: dict[str, Var | str] | None = None,
+    html_custom_attrs: dict[str, Var | Any] | None = None,
 ) -> Component:
     """Create the document root.
 

reflex/components/base/bare.py

@@ -188,6 +188,23 @@ class Bare(Component):
             return Tagless(contents=f"{contents.to_string()!s}")
         return Tagless(contents=f"{contents!s}")
 
+    def render(self) -> dict:
+        """Render the component as a dictionary.
+
+        This is overridden to provide a short performant path for rendering.
+
+        Returns:
+            The rendered component.
+        """
+        contents = (
+            Var.create(self.contents)
+            if not isinstance(self.contents, Var)
+            else self.contents
+        )
+        if isinstance(contents, (BooleanVar, ObjectVar)):
+            return {"contents": f"{contents.to_string()!s}"}
+        return {"contents": f"{contents!s}"}
+
     def _add_style_recursive(
         self, style: ComponentStyle, theme: Component | None = None
     ) -> Component:

reflex/components/component.py

@@ -22,7 +22,7 @@ from typing_extensions import dataclass_transform
 
 import reflex.state
 from reflex import constants
-from reflex.compiler.templates import STATEFUL_COMPONENT
+from reflex.compiler.templates import stateful_component_template
 from reflex.components.core.breakpoints import Breakpoints
 from reflex.components.dynamic import load_dynamic_serializer
 from reflex.components.field import BaseField, FieldBasedMeta
@@ -51,7 +51,7 @@ from reflex.event import (
 )
 from reflex.style import Style, format_as_emotion
 from reflex.utils import console, format, imports, types
-from reflex.utils.imports import ImportDict, ImportVar, ParsedImportDict, parse_imports
+from reflex.utils.imports import ImportDict, ImportVar, ParsedImportDict
 from reflex.vars import VarData
 from reflex.vars.base import (
     CachedVarOperation,
@@ -1270,7 +1270,6 @@ class Component(BaseComponent, ABC):
         rendered_dict = dict(
             tag.set(
                 children=[child.render() for child in self.children],
-                contents=str(tag.contents),
             )
         )
         self._replace_prop_names(rendered_dict)
@@ -1498,7 +1497,7 @@ class Component(BaseComponent, ABC):
             yield clz.__name__
 
     @classmethod
-    def _iter_parent_classes_with_method(cls, method: str) -> Iterator[type[Component]]:
+    def _iter_parent_classes_with_method(cls, method: str) -> Sequence[type[Component]]:
         """Iterate through parent classes that define a given method.
 
         Used for handling the `add_*` API functions that internally simulate a super() call chain.
@@ -1506,12 +1505,13 @@ class Component(BaseComponent, ABC):
         Args:
             method: The method to look for.
 
-        Yields:
-            The parent classes that define the method (differently than the base).
+        Returns:
+            A sequence of parent classes that define the method (differently than the base).
         """
         seen_methods = (
             {getattr(Component, method)} if hasattr(Component, method) else set()
         )
+        clzs: list[type[Component]] = []
         for clz in cls.mro():
             if clz is Component:
                 break
@@ -1521,7 +1521,8 @@ class Component(BaseComponent, ABC):
             if not callable(method_func) or method_func in seen_methods:
                 continue
             seen_methods.add(method_func)
-            yield clz
+            clzs.append(clz)
+        return clzs
 
     def _get_custom_code(self) -> str | None:
         """Get custom code for the component.
@@ -1644,18 +1645,18 @@ class Component(BaseComponent, ABC):
         Returns:
             The imports needed by the component.
         """
-        _imports = {}
-
-        # Import this component's tag from the main library.
-        if self.library is not None and self.tag is not None:
-            _imports[self.library] = self.import_var
+        _imports = (
+            {self.library: [self.import_var]}
+            if self.library is not None and self.tag is not None
+            else {}
+        )
 
         # Get static imports required for event processing.
         event_imports = Imports.EVENTS if self.event_triggers else {}
 
         # Collect imports from Vars used directly by this component.
         var_imports = [
-            var_data.imports
+            dict(var_data.imports)
             for var in self._get_vars()
             if (var_data := var._get_all_var_data()) is not None
         ]
@@ -1665,16 +1666,16 @@ class Component(BaseComponent, ABC):
             list_of_import_dict = clz.add_imports(self)
 
             if not isinstance(list_of_import_dict, list):
-                list_of_import_dict = [list_of_import_dict]
-
-            added_import_dicts.extend(
-                [parse_imports(import_dict) for import_dict in list_of_import_dict]
-            )
+                added_import_dicts.append(imports.parse_imports(list_of_import_dict))
+            else:
+                added_import_dicts.extend(
+                    [imports.parse_imports(item) for item in list_of_import_dict]
+                )
 
-        return imports.merge_imports(
+        return imports.merge_parsed_imports(
             self._get_dependencies_imports(),
             self._get_hooks_imports(),
-            {**_imports},
+            _imports,
             event_imports,
             *var_imports,
             *added_import_dicts,
@@ -1689,7 +1690,7 @@ class Component(BaseComponent, ABC):
         Returns:
             The import dict with the required imports.
         """
-        _imports = imports.merge_imports(
+        _imports = imports.merge_parsed_imports(
             self._get_imports(), *[child._get_all_imports() for child in self.children]
         )
         return imports.collapse_imports(_imports) if collapse else _imports
@@ -2470,7 +2471,7 @@ class StatefulComponent(BaseComponent):
         if not self.tag:
             return ""
         # Render the code for this component and hooks.
-        return STATEFUL_COMPONENT.render(
+        return stateful_component_template(
             tag_name=self.tag,
             memo_trigger_hooks=self.memo_trigger_hooks,
             component=self.component,
@@ -2598,7 +2599,7 @@ class StatefulComponent(BaseComponent):
             memo_name = f"{event_trigger}_{chain_hash}"
 
             # Calculate Var dependencies accessed by the handler for useCallback dep array.
-            var_deps = ["addEvents", "Event"]
+            var_deps = ["addEvents", "ReflexEvent"]
 
             # Get deps from event trigger var data.
             var_deps.extend(cls._get_deps_from_event_trigger(event))
@@ -2796,6 +2797,9 @@ def render_dict_to_var(tag: dict | Component | str) -> Var:
             return render_dict_to_var(tag.render())
         return Var.create(tag)
 
+    if "contents" in tag:
+        return Var(tag["contents"])
+
     if "iterable" in tag:
         function_return = LiteralArrayVar.create(
             [render_dict_to_var(child.render()) for child in tag["children"]]
@@ -2813,27 +2817,30 @@ def render_dict_to_var(tag: dict | Component | str) -> Var:
             func,
         )
 
-    if tag["name"] == "match":
-        element = tag["cond"]
+    if "match_cases" in tag:
+        element = Var(tag["cond"])
 
         conditionals = render_dict_to_var(tag["default"])
 
         for case in tag["match_cases"][::-1]:
-            condition = case[0].to_string() == element.to_string()
-            for pattern in case[1:-1]:
-                condition = condition | (pattern.to_string() == element.to_string())
+            conditions, return_value = case
+            condition = Var.create(False)
+            for pattern in conditions:
+                condition = condition | (
+                    Var(pattern).to_string() == element.to_string()
+                )
 
             conditionals = ternary_operation(
                 condition,
-                render_dict_to_var(case[-1]),
+                render_dict_to_var(return_value),
                 conditionals,
             )
 
         return conditionals
 
-    if "cond" in tag:
+    if "cond_state" in tag:
         return ternary_operation(
-            tag["cond"],
+            Var(tag["cond_state"]),
             render_dict_to_var(tag["true_value"]),
             render_dict_to_var(tag["false_value"])
             if tag["false_value"] is not None
@@ -2842,8 +2849,6 @@ def render_dict_to_var(tag: dict | Component | str) -> Var:
 
     props = Var("({" + ",".join(tag["props"]) + "})")
 
-    contents = tag["contents"] if tag["contents"] else None
-
     raw_tag_name = tag.get("name")
     tag_name = Var(raw_tag_name or "Fragment")
 
@@ -2852,7 +2857,6 @@ def render_dict_to_var(tag: dict | Component | str) -> Var:
     ).call(
         tag_name,
         props,
-        *([Var(contents)] if contents is not None else []),
         *[render_dict_to_var(child) for child in tag["children"]],
     )
 

reflex/components/core/cond.py

@@ -61,7 +61,7 @@ class Cond(Component):
 
     def _render(self) -> Tag:
         return CondTag(
-            cond=self.cond,
+            cond_state=str(self.cond),
             true_value=self.children[0].render(),
             false_value=self.children[1].render(),
         )
@@ -72,17 +72,11 @@ class Cond(Component):
         Returns:
             The dictionary for template of component.
         """
-        tag = self._render()
-        return dict(
-            tag.add_props(
-                **self.event_triggers,
-                key=self.key,
-                sx=self.style,
-                id=self.id,
-                class_name=self.class_name,
-            ),
-            cond_state=str(self.cond),
-        )
+        return {
+            "cond_state": str(self.cond),
+            "true_value": self.children[0].render(),
+            "false_value": self.children[1].render(),
+        }
 
     def add_imports(self) -> ImportDict:
         """Add imports for the Cond component.

reflex/components/core/foreach.py

@@ -181,7 +181,7 @@ class Foreach(Component):
             tag,
             iterable_state=str(tag.iterable),
             arg_name=tag.arg_var_name,
-            arg_index=tag.get_index_var_arg(),
+            arg_index=tag.index_var_name,
         )
 
 

reflex/components/core/match.py

@@ -1,11 +1,12 @@
 """rx.match."""
 
 import textwrap
-from typing import Any
+from typing import Any, cast
 
 from reflex.components.base import Fragment
 from reflex.components.component import BaseComponent, Component, MemoizationLeaf, field
-from reflex.components.tags import MatchTag, Tag
+from reflex.components.tags import Tag
+from reflex.components.tags.match_tag import MatchTag
 from reflex.style import Style
 from reflex.utils import format
 from reflex.utils.exceptions import MatchTypeError
@@ -21,10 +22,14 @@ class Match(MemoizationLeaf):
     cond: Var[Any]
 
     # The list of match cases to be matched.
-    match_cases: list[Any] = field(default_factory=list, is_javascript_property=False)
+    match_cases: list[tuple[list[Var], BaseComponent]] = field(
+        default_factory=list, is_javascript_property=False
+    )
 
     # The catchall case to match.
-    default: Any = field(default=None, is_javascript_property=False)
+    default: BaseComponent = field(
+        default_factory=Fragment.create, is_javascript_property=False
+    )
 
     @classmethod
     def create(cls, cond: Any, *cases) -> Component | Var:
@@ -44,9 +49,9 @@ class Match(MemoizationLeaf):
         cases, default = cls._process_cases(list(cases))
         match_cases = cls._process_match_cases(cases)
 
-        cls._validate_return_types(match_cases)
+        match_cases = cls._validate_return_types(match_cases)
 
-        if default is None and isinstance(match_cases[0][-1], Var):
+        if default is None and isinstance(match_cases[0][1], Var):
             msg = "For cases with return types as Vars, a default case must be provided"
             raise ValueError(msg)
 
@@ -75,7 +80,9 @@ class Match(MemoizationLeaf):
         return match_cond_var
 
     @classmethod
-    def _process_cases(cls, cases: list) -> tuple[list, Var | BaseComponent | None]:
+    def _process_cases(
+        cls, cases: list
+    ) -> tuple[list[tuple], Var | BaseComponent | None]:
         """Process the list of match cases and the catchall default case.
 
         Args:
@@ -87,26 +94,29 @@ class Match(MemoizationLeaf):
         Raises:
             ValueError: If there are multiple default cases.
         """
-        default = None
-
-        if len([case for case in cases if not isinstance(case, tuple)]) > 1:
-            msg = "rx.match can only have one default case."
-            raise ValueError(msg)
-
         if not cases:
             msg = "rx.match should have at least one case."
             raise ValueError(msg)
 
-        # Get the default case which should be the last non-tuple arg
         if not isinstance(cases[-1], tuple):
-            default = cases.pop()
-            default = (
-                cls._create_case_var_with_var_data(default)
-                if not isinstance(default, BaseComponent)
-                else default
+            *cases, default_return = cases
+            default_return = (
+                cls._create_case_var_with_var_data(default_return)
+                if not isinstance(default_return, BaseComponent)
+                else default_return
             )
+        else:
+            default_return = None
 
-        return cases, default
+        if any(case for case in cases if not isinstance(case, tuple)):
+            msg = "rx.match should have tuples of cases and one default case as the last argument."
+            raise ValueError(msg)
+
+        if not cases:
+            msg = "rx.match should have at least one case."
+            raise ValueError(msg)
+
+        return cases, default_return
 
     @classmethod
     def _create_case_var_with_var_data(cls, case_element: Any) -> Var:
@@ -124,7 +134,9 @@ class Match(MemoizationLeaf):
         return LiteralVar.create(case_element, _var_data=_var_data)
 
     @classmethod
-    def _process_match_cases(cls, cases: list) -> list[list[Var]]:
+    def _process_match_cases(
+        cls, cases: list[tuple]
+    ) -> list[tuple[list[Var], BaseComponent | Var]]:
         """Process the individual match cases.
 
         Args:
@@ -136,40 +148,48 @@ class Match(MemoizationLeaf):
         Raises:
             ValueError: If the default case is not the last case or the tuple elements are less than 2.
         """
-        match_cases = []
-        for case in cases:
-            if not isinstance(case, tuple):
-                msg = "rx.match should have tuples of cases and a default case as the last argument."
-                raise ValueError(msg)
+        match_cases: list[tuple[list[Var], BaseComponent | Var]] = []
+        for case_index, case in enumerate(cases):
             # There should be at least two elements in a case tuple(a condition and return value)
             if len(case) < 2:
                 msg = "A case tuple should have at least a match case element and a return value."
                 raise ValueError(msg)
 
-            case_list = []
-            for element in case:
-                # convert all non component element to vars.
-                el = (
-                    cls._create_case_var_with_var_data(element)
-                    if not isinstance(element, BaseComponent)
-                    else element
-                )
-                if not isinstance(el, (Var, BaseComponent)):
-                    msg = "Case element must be a var or component"
+            *conditions, return_value = case
+
+            conditions_vars: list[Var] = []
+            for condition_index, condition in enumerate(conditions):
+                if isinstance(condition, BaseComponent):
+                    msg = f"Match condition {condition_index} of case {case_index} cannot be a component."
                     raise ValueError(msg)
-                case_list.append(el)
+                conditions_vars.append(cls._create_case_var_with_var_data(condition))
+
+            return_value = (
+                cls._create_case_var_with_var_data(return_value)
+                if not isinstance(return_value, BaseComponent)
+                else return_value
+            )
+
+            if not isinstance(return_value, (Var, BaseComponent)):
+                msg = "Return value must be a var or component"
+                raise ValueError(msg)
 
-            match_cases.append(case_list)
+            match_cases.append((conditions_vars, return_value))
 
         return match_cases
 
     @classmethod
-    def _validate_return_types(cls, match_cases: list[list[Var]]) -> None:
+    def _validate_return_types(
+        cls, match_cases: list[tuple[list[Var], BaseComponent | Var]]
+    ) -> list[tuple[list[Var], Var]] | list[tuple[list[Var], BaseComponent]]:
         """Validate that match cases have the same return types.
 
         Args:
             match_cases: The match cases.
 
+        Returns:
+            The validated match cases.
+
         Raises:
             MatchTypeError: If the return types of cases are different.
         """
@@ -181,20 +201,25 @@ class Match(MemoizationLeaf):
         elif isinstance(first_case_return, Var):
             return_type = Var
 
+        cases = []
         for index, case in enumerate(match_cases):
-            if not isinstance(case[-1], return_type):
+            conditions, return_value = case
+            if not isinstance(return_value, return_type):
                 msg = (
                     f"Match cases should have the same return types. Case {index} with return "
-                    f"value `{case[-1]._js_expr if isinstance(case[-1], Var) else textwrap.shorten(str(case[-1]), width=250)}`"
-                    f" of type {type(case[-1])!r} is not {return_type}"
+                    f"value `{return_value._js_expr if isinstance(return_value, Var) else textwrap.shorten(str(return_value), width=250)}`"
+                    f" of type {type(return_value)!r} is not {return_type}"
                 )
                 raise MatchTypeError(msg)
+            cases.append((conditions, return_value))
+        return cases
 
     @classmethod
     def _create_match_cond_var_or_component(
         cls,
         match_cond_var: Var,
-        match_cases: list[list[Var]],
+        match_cases: list[tuple[list[Var], BaseComponent]]
+        | list[tuple[list[Var], Var]],
         default: Var | BaseComponent | None,
     ) -> Component | Var:
         """Create and return the match condition var or component.
@@ -206,29 +231,22 @@ class Match(MemoizationLeaf):
 
         Returns:
             The match component wrapped in a fragment or the match var.
-
-        Raises:
-            ValueError: If the return types are not vars when creating a match var for Var types.
         """
-        if default is None and isinstance(match_cases[0][-1], BaseComponent):
-            default = Fragment.create()
+        if isinstance(match_cases[0][1], BaseComponent):
+            if default is None:
+                default = Fragment.create()
 
-        if isinstance(match_cases[0][-1], BaseComponent):
             return Fragment.create(
                 cls._create(
                     cond=match_cond_var,
                     match_cases=match_cases,
                     default=default,
-                    children=[case[-1] for case in match_cases] + [default],  # pyright: ignore [reportArgumentType]
+                    children=[case[1] for case in match_cases] + [default],  # pyright: ignore [reportArgumentType]
                 )
             )
 
-        # Validate the match cases (as well as the default case) to have Var return types.
-        if any(
-            case for case in match_cases if not isinstance(case[-1], Var)
-        ) or not isinstance(default, Var):
-            msg = "Return types of match cases should be Vars."
-            raise ValueError(msg)
+        match_cases = cast("list[tuple[list[Var], Var]]", match_cases)
+        default = cast("Var", default)
 
         return Var(
             _js_expr=format.format_match(
@@ -239,14 +257,20 @@ class Match(MemoizationLeaf):
             _var_type=default._var_type,
             _var_data=VarData.merge(
                 match_cond_var._get_all_var_data(),
-                *[el._get_all_var_data() for case in match_cases for el in case],
+                *[el._get_all_var_data() for case in match_cases for el in case[0]],
+                *[case[1]._get_all_var_data() for case in match_cases],
                 default._get_all_var_data(),
             ),
         )
 
     def _render(self) -> Tag:
         return MatchTag(
-            cond=self.cond, match_cases=self.match_cases, default=self.default
+            cond=str(self.cond),
+            match_cases=[
+                ([str(cond) for cond in conditions], return_value.render())
+                for conditions, return_value in self.match_cases
+            ],
+            default=self.default.render(),
         )
 
     def render(self) -> dict:
@@ -255,8 +279,7 @@ class Match(MemoizationLeaf):
         Returns:
             The dictionary for template of component.
         """
-        tag = self._render()
-        return dict(tag.set(name="match"))
+        return dict(self._render())
 
     def add_imports(self) -> ImportDict:
         """Add imports for the Match component.

reflex/components/dynamic.py

@@ -86,7 +86,7 @@ def load_dynamic_serializer():
         )
 
         rendered_components[
-            templates.STATEFUL_COMPONENT.render(
+            templates.stateful_component_template(
                 tag_name="MySSRComponent",
                 memo_trigger_hooks=[],
                 component=component,
@@ -111,10 +111,10 @@ def load_dynamic_serializer():
             else:
                 imports[lib] = names
 
-        module_code_lines = templates.STATEFUL_COMPONENTS.render(
+        module_code_lines = templates.stateful_components_template(
             imports=utils.compile_imports(imports),
             memoized_code="\n".join(rendered_components),
-        ).splitlines()[1:]
+        ).splitlines()
 
         # Rewrite imports from `/` to destructure from window
         for ix, line in enumerate(module_code_lines[:]):