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

reflex/utils/format.py

@@ -10,7 +10,7 @@ from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
 
 from reflex import constants
 from reflex.utils import exceptions, types
-from reflex.vars import Var
+from reflex.utils.console import deprecate
 
 if TYPE_CHECKING:
     from reflex.components.component import ComponentStyle
@@ -298,9 +298,9 @@ def format_route(route: str, format_case=True) -> str:
 
 
 def format_match(
-    cond: str | ImmutableVar,
-    match_cases: List[List[ImmutableVar]],
-    default: ImmutableVar,
+    cond: str | Var,
+    match_cases: List[List[Var]],
+    default: Var,
 ) -> str:
     """Format a match expression whose return type is a Var.
 
@@ -332,7 +332,7 @@ def format_match(
 
 
 def format_prop(
-    prop: Union[ImmutableVar, EventChain, ComponentStyle, str],
+    prop: Union[Var, EventChain, ComponentStyle, str],
 ) -> Union[int, float, str]:
     """Format a prop.
 
@@ -348,12 +348,12 @@ def format_prop(
     """
     # import here to avoid circular import.
     from reflex.event import EventChain
-    from reflex.ivars import ImmutableVar
     from reflex.utils import serializers
+    from reflex.vars import Var
 
     try:
         # Handle var props.
-        if isinstance(prop, ImmutableVar):
+        if isinstance(prop, Var):
             return str(prop)
 
         # Handle event props.
@@ -406,26 +406,15 @@ def format_props(*single_props, **key_value_props) -> list[str]:
         The formatted props list.
     """
     # Format all the props.
-    from reflex.ivars.base import ImmutableVar, LiteralVar
+    from reflex.vars.base import LiteralVar, Var
 
     return [
         (
-            f"{name}={format_prop(prop)}"
-            if isinstance(prop, ImmutableVar) and not isinstance(prop, ImmutableVar)
-            else (
-                f"{name}={{{format_prop(prop if isinstance(prop, ImmutableVar) else LiteralVar.create(prop))}}}"
-            )
+            f"{name}={{{format_prop(prop if isinstance(prop, Var) else LiteralVar.create(prop))}}}"
         )
         for name, prop in sorted(key_value_props.items())
         if prop is not None
-    ] + [
-        (
-            str(prop)
-            if isinstance(prop, ImmutableVar) and not isinstance(prop, ImmutableVar)
-            else f"{str(LiteralVar.create(prop))}"
-        )
-        for prop in single_props
-    ]
+    ] + [(f"{str(LiteralVar.create(prop))}") for prop in single_props]
 
 
 def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
@@ -486,10 +475,10 @@ def format_event(event_spec: EventSpec) -> str:
         [
             ":".join(
                 (
-                    name._var_name,
+                    name._js_expr,
                     (
                         wrap(
-                            json.dumps(val._var_name).strip('"').replace("`", "\\`"),
+                            json.dumps(val._js_expr).strip('"').replace("`", "\\`"),
                             "`",
                         )
                         if val._var_is_string
@@ -511,7 +500,38 @@ def format_event(event_spec: EventSpec) -> str:
 
 
 if TYPE_CHECKING:
-    from reflex.ivars import ImmutableVar
+    from reflex.vars import Var
+
+
+def format_event_chain(
+    event_chain: EventChain | Var[EventChain],
+    event_arg: Var | None = None,
+) -> str:
+    """DEPRECATED: format an event chain as a javascript invocation.
+
+    Use str(rx.Var.create(event_chain)) instead.
+
+    Args:
+        event_chain: The event chain to format.
+        event_arg: this argument is ignored.
+
+    Returns:
+        Compiled javascript code to queue the given event chain on the frontend.
+    """
+    deprecate(
+        feature_name="format_event_chain",
+        reason="Use str(rx.Var.create(event_chain)) instead",
+        deprecation_version="0.6.0",
+        removal_version="0.7.0",
+    )
+
+    from reflex.vars import Var
+    from reflex.vars.function import ArgsFunctionOperation
+
+    result = Var.create(event_chain)
+    if isinstance(result, ArgsFunctionOperation):
+        result = result._return_expr
+    return str(result)
 
 
 def format_queue_events(
@@ -523,7 +543,7 @@ def format_queue_events(
         | None
     ) = None,
     args_spec: Optional[ArgsSpec] = None,
-) -> ImmutableVar[EventChain]:
+) -> Var[EventChain]:
     """Format a list of event handler / event spec as a javascript callback.
 
     The resulting code can be passed to interfaces that expect a callback
@@ -549,10 +569,10 @@ def format_queue_events(
         call_event_fn,
         call_event_handler,
     )
-    from reflex.ivars import FunctionVar, ImmutableVar
+    from reflex.vars import FunctionVar, Var
 
     if not events:
-        return ImmutableVar("(() => null)").to(FunctionVar, EventChain)  # type: ignore
+        return Var("(() => null)").to(FunctionVar, EventChain)  # type: ignore
 
     # If no spec is provided, the function will take no arguments.
     def _default_args_spec():
@@ -577,7 +597,7 @@ def format_queue_events(
             specs = [call_event_handler(spec, args_spec or _default_args_spec)]
         elif isinstance(spec, type(lambda: None)):
             specs = call_event_fn(spec, args_spec or _default_args_spec)  # type: ignore
-            if isinstance(specs, ImmutableVar):
+            if isinstance(specs, Var):
                 raise ValueError(
                     f"Invalid event spec: {specs}. Expected a list of EventSpecs."
                 )
@@ -585,7 +605,7 @@ def format_queue_events(
 
     # Return the final code snippet, expecting queueEvents, processEvent, and socket to be in scope.
     # Typically this snippet will _only_ run from within an rx.call_script eval context.
-    return ImmutableVar(
+    return Var(
         f"{arg_def} => {{queueEvents([{','.join(payloads)}], {constants.CompileVars.SOCKET}); "
         f"processEvent({constants.CompileVars.SOCKET})}}",
     ).to(FunctionVar, EventChain)  # type: ignore
@@ -727,7 +747,7 @@ def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
     return collapsed
 
 
-def format_array_ref(refs: str, idx: ImmutableVar | None) -> str:
+def format_array_ref(refs: str, idx: Var | None) -> str:
     """Format a ref accessed by array.
 
     Args:
@@ -756,7 +776,7 @@ def format_data_editor_column(col: str | dict):
     Returns:
         The formatted column.
     """
-    from reflex.ivars import ImmutableVar
+    from reflex.vars import Var
 
     if isinstance(col, str):
         return {"title": col, "id": col.lower(), "type": "str"}
@@ -770,7 +790,7 @@ def format_data_editor_column(col: str | dict):
             col["overlayIcon"] = None
         return col
 
-    if isinstance(col, ImmutableVar):
+    if isinstance(col, Var):
         return col
 
     raise ValueError(
@@ -787,9 +807,9 @@ def format_data_editor_cell(cell: Any):
     Returns:
         The formatted cell.
     """
-    from reflex.ivars.base import ImmutableVar
+    from reflex.vars.base import Var
 
     return {
-        "kind": ImmutableVar.create("GridCellKind.Text"),
+        "kind": Var(_js_expr="GridCellKind.Text"),
         "data": cell,
     }

reflex/utils/imports.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
+import dataclasses
 from collections import defaultdict
-from typing import Dict, List, Optional, Tuple, Union
-
-from reflex.base import Base
+from typing import DefaultDict, Dict, List, Optional, Tuple, Union
 
 
 def merge_imports(
@@ -19,12 +18,22 @@ def merge_imports(
     Returns:
         The merged import dicts.
     """
-    all_imports = defaultdict(list)
+    all_imports: DefaultDict[str, List[ImportVar]] = defaultdict(list)
     for import_dict in imports:
         for lib, fields in (
             import_dict if isinstance(import_dict, tuple) else import_dict.items()
         ):
-            all_imports[lib].extend(fields)
+            if isinstance(fields, (list, tuple, set)):
+                all_imports[lib].extend(
+                    (
+                        ImportVar(field) if isinstance(field, str) else field
+                        for field in fields
+                    )
+                )
+            else:
+                all_imports[lib].append(
+                    ImportVar(fields) if isinstance(fields, str) else fields
+                )
     return all_imports
 
 
@@ -75,7 +84,8 @@ def collapse_imports(
     }
 
 
-class ImportVar(Base):
+@dataclasses.dataclass(order=True, frozen=True)
+class ImportVar:
     """An import var."""
 
     # The name of the import tag.
@@ -111,73 +121,6 @@ class ImportVar(Base):
         else:
             return self.tag or ""
 
-    def __lt__(self, other: ImportVar) -> bool:
-        """Compare two ImportVar objects.
-
-        Args:
-            other: The other ImportVar object to compare.
-
-        Returns:
-            Whether this ImportVar object is less than the other.
-        """
-        return (
-            self.tag,
-            self.is_default,
-            self.alias,
-            self.install,
-            self.render,
-            self.transpile,
-        ) < (
-            other.tag,
-            other.is_default,
-            other.alias,
-            other.install,
-            other.render,
-            other.transpile,
-        )
-
-    def __eq__(self, other: ImportVar) -> bool:
-        """Check if two ImportVar objects are equal.
-
-        Args:
-            other: The other ImportVar object to compare.
-
-        Returns:
-            Whether the two ImportVar objects are equal.
-        """
-        return (
-            self.tag,
-            self.is_default,
-            self.alias,
-            self.install,
-            self.render,
-            self.transpile,
-        ) == (
-            other.tag,
-            other.is_default,
-            other.alias,
-            other.install,
-            other.render,
-            other.transpile,
-        )
-
-    def __hash__(self) -> int:
-        """Hash the ImportVar object.
-
-        Returns:
-            The hash of the ImportVar object.
-        """
-        return hash(
-            (
-                self.tag,
-                self.is_default,
-                self.alias,
-                self.install,
-                self.render,
-                self.transpile,
-            )
-        )
-
 
 ImportTypes = Union[str, ImportVar, List[Union[str, ImportVar]], List[ImportVar]]
 ImportDict = Dict[str, ImportTypes]

reflex/utils/prerequisites.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import functools
 import glob
 import importlib
@@ -32,7 +33,6 @@ from redis import exceptions
 from redis.asyncio import Redis
 
 from reflex import constants, model
-from reflex.base import Base
 from reflex.compiler import templates
 from reflex.config import Config, get_config
 from reflex.utils import console, net, path_ops, processes
@@ -42,7 +42,8 @@ from reflex.utils.registry import _get_best_registry
 CURRENTLY_INSTALLING_NODE = False
 
 
-class Template(Base):
+@dataclasses.dataclass(frozen=True)
+class Template:
     """A template for a Reflex app."""
 
     name: str
@@ -51,7 +52,8 @@ class Template(Base):
     demo_url: str
 
 
-class CpuInfo(Base):
+@dataclasses.dataclass(frozen=True)
+class CpuInfo:
     """Model to save cpu info."""
 
     manufacturer_id: Optional[str]
@@ -1277,11 +1279,16 @@ def fetch_app_templates(version: str) -> dict[str, Template]:
             ),
             None,
         )
-    return {
-        tp["name"]: Template.parse_obj(tp)
-        for tp in templates_data
-        if not tp["hidden"] and tp["code_url"] is not None
-    }
+
+    filtered_templates = {}
+    for tp in templates_data:
+        if tp["hidden"] or tp["code_url"] is None:
+            continue
+        known_fields = set(f.name for f in dataclasses.fields(Template))
+        filtered_templates[tp["name"]] = Template(
+            **{k: v for k, v in tp.items() if k in known_fields}
+        )
+    return filtered_templates
 
 
 def create_config_init_app_from_remote_template(app_name: str, template_url: str):

reflex/utils/pyi_generator.py

@@ -19,8 +19,8 @@ from types import ModuleType, SimpleNamespace
 from typing import Any, Callable, Iterable, Type, get_args
 
 from reflex.components.component import Component
-from reflex.ivars.base import ImmutableVar
 from reflex.utils import types as rx_types
+from reflex.vars.base import Var
 
 logger = logging.getLogger("pyi_generator")
 
@@ -69,11 +69,10 @@ DEFAULT_TYPING_IMPORTS = {
 # TODO: fix import ordering and unused imports with ruff later
 DEFAULT_IMPORTS = {
     "typing": sorted(DEFAULT_TYPING_IMPORTS),
-    "reflex.vars": ["Var"],
     "reflex.components.core.breakpoints": ["Breakpoints"],
     "reflex.event": ["EventChain", "EventHandler", "EventSpec"],
     "reflex.style": ["Style"],
-    "reflex.ivars.base": ["ImmutableVar"],
+    "reflex.vars.base": ["Var"],
 }
 
 
@@ -151,7 +150,7 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
 
     if args:
         inner_container_type_args = (
-            [repr(arg) for arg in args]
+            sorted((repr(arg) for arg in args))
             if rx_types.is_literal(value)
             else [
                 _get_type_hint(arg, type_hint_globals, is_optional=False)
@@ -185,7 +184,7 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
                 if arg is not type(None)
             ]
             if len(types) > 1:
-                res = ", ".join(types)
+                res = ", ".join(sorted(types))
                 res = f"Union[{res}]"
     elif isinstance(value, str):
         ev = eval(value, type_hint_globals)
@@ -356,7 +355,7 @@ def _extract_class_props_as_ast_nodes(
                 with contextlib.suppress(AttributeError, KeyError):
                     # Try to get default from pydantic field definition.
                     default = target_class.__fields__[name].default
-                    if isinstance(default, ImmutableVar):
+                    if isinstance(default, Var):
                         default = default._decode()  # type: ignore
 
             kwargs.append(
@@ -434,7 +433,7 @@ def _generate_component_create_functiondef(
             ast.arg(
                 arg=trigger,
                 annotation=ast.Name(
-                    id="Optional[Union[EventHandler, EventSpec, list, Callable, ImmutableVar]]"
+                    id="Optional[Union[EventHandler, EventSpec, list, Callable, Var]]"
                 ),
             ),
             ast.Constant(value=None),
@@ -903,7 +902,13 @@ class PyiGenerator:
             # construct the import statement and handle special cases for aliases
             sub_mod_attrs_imports = [
                 f"from .{path} import {mod if not isinstance(mod, tuple) else mod[0]} as {mod if not isinstance(mod, tuple) else mod[1]}"
-                + ("  # type: ignore" if mod in pyright_ignore_imports else "")
+                + (
+                    "  # type: ignore"
+                    if mod in pyright_ignore_imports
+                    else "  # noqa"  # ignore ruff formatting here for cases like rx.list.
+                    if isinstance(mod, tuple)
+                    else ""
+                )
                 for mod, path in sub_mod_attrs.items()
             ]
             sub_mod_attrs_imports.append("")

reflex/utils/serializers.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import functools
 import json
 import warnings
@@ -29,7 +30,7 @@ from reflex.utils import types
 
 # Mapping from type to a serializer.
 # The serializer should convert the type to a JSON object.
-SerializedType = Union[str, bool, int, float, list, dict]
+SerializedType = Union[str, bool, int, float, list, dict, None]
 
 
 Serializer = Callable[[Type], SerializedType]
@@ -124,6 +125,8 @@ def serialize(
 
     # If there is no serializer, return None.
     if serializer is None:
+        if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            return serialize(dataclasses.asdict(value))
         if get_type:
             return None, None
         return None
@@ -225,7 +228,7 @@ def serialize_str(value: str) -> str:
 
 
 @serializer
-def serialize_primitive(value: Union[bool, int, float, None]) -> str:
+def serialize_primitive(value: Union[bool, int, float, None]):
     """Serialize a primitive type.
 
     Args:
@@ -234,13 +237,11 @@ def serialize_primitive(value: Union[bool, int, float, None]) -> str:
     Returns:
         The serialized number/bool/None.
     """
-    from reflex.utils import format
-
-    return format.json_dumps(value)
+    return value
 
 
 @serializer
-def serialize_base(value: Base) -> str:
+def serialize_base(value: Base) -> dict:
     """Serialize a Base instance.
 
     Args:
@@ -249,18 +250,11 @@ def serialize_base(value: Base) -> str:
     Returns:
         The serialized Base.
     """
-    from reflex.ivars import LiteralObjectVar
-
-    return str(
-        LiteralObjectVar.create(
-            {k: (None if callable(v) else v) for k, v in value.dict().items()},
-            _var_type=type(value),
-        )
-    )
+    return {k: serialize(v) for k, v in value.dict().items() if not callable(v)}
 
 
 @serializer
-def serialize_list(value: Union[List, Tuple, Set]) -> str:
+def serialize_list(value: Union[List, Tuple, Set]) -> list:
     """Serialize a list to a JSON string.
 
     Args:
@@ -269,13 +263,11 @@ def serialize_list(value: Union[List, Tuple, Set]) -> str:
     Returns:
         The serialized list.
     """
-    from reflex.ivars import LiteralArrayVar
-
-    return str(LiteralArrayVar.create(value))
+    return [serialize(item) for item in value]
 
 
 @serializer
-def serialize_dict(prop: Dict[str, Any]) -> str:
+def serialize_dict(prop: Dict[str, Any]) -> dict:
     """Serialize a dictionary to a JSON string.
 
     Args:
@@ -284,9 +276,7 @@ def serialize_dict(prop: Dict[str, Any]) -> str:
     Returns:
         The serialized dictionary.
     """
-    from reflex.ivars import LiteralObjectVar
-
-    return str(LiteralObjectVar.create(prop))
+    return {k: serialize(v) for k, v in prop.items()}
 
 
 @serializer(to=str)

reflex/utils/telemetry.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import multiprocessing
 import platform
 import warnings
@@ -120,7 +121,7 @@ def _prepare_event(event: str, **kwargs) -> dict:
         return {}
 
     if UTC is None:
-        # for python 3.8, 3.9 & 3.10
+        # for python 3.10
         stamp = datetime.utcnow().isoformat()
     else:
         # for python 3.11 & 3.12
@@ -144,7 +145,7 @@ def _prepare_event(event: str, **kwargs) -> dict:
             "python_version": get_python_version(),
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
-            "cpu_info": dict(cpuinfo) if cpuinfo else {},
+            "cpu_info": dataclasses.asdict(cpuinfo) if cpuinfo else {},
             **additional_fields,
         },
         "timestamp": stamp,

reflex/utils/types.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import contextlib
+import dataclasses
 import inspect
 import sys
 import types
@@ -95,7 +96,7 @@ PrimitiveType = Union[int, float, bool, str, list, dict, set, tuple]
 StateVar = Union[PrimitiveType, Base, None]
 StateIterVar = Union[list, set, tuple]
 
-# ArgsSpec = Callable[[ImmutableVar], list[ImmutableVar]]
+# ArgsSpec = Callable[[Var], list[Var]]
 ArgsSpec = Callable
 
 
@@ -480,7 +481,11 @@ def is_valid_var_type(type_: Type) -> bool:
 
     if is_union(type_):
         return all((is_valid_var_type(arg) for arg in get_args(type_)))
-    return _issubclass(type_, StateVar) or serializers.has_serializer(type_)
+    return (
+        _issubclass(type_, StateVar)
+        or serializers.has_serializer(type_)
+        or dataclasses.is_dataclass(type_)
+    )
 
 
 def is_backend_base_variable(name: str, cls: Type) -> bool:
@@ -514,7 +519,7 @@ def is_backend_base_variable(name: str, cls: Type) -> bool:
     if name in cls.inherited_backend_vars:
         return False
 
-    from reflex.ivars.base import is_computed_var
+    from reflex.vars.base import is_computed_var
 
     if name in cls.__dict__:
         value = cls.__dict__[name]
@@ -590,11 +595,11 @@ def validate_literal(key: str, value: Any, expected_type: Type, comp_name: str):
     Raises:
         ValueError: When the value is not a valid literal.
     """
-    from reflex.ivars import ImmutableVar
+    from reflex.vars import Var
 
     if (
         is_literal(expected_type)
-        and not isinstance(value, ImmutableVar)  # validating vars is not supported yet.
+        and not isinstance(value, Var)  # validating vars is not supported yet.
         and not is_encoded_fstring(value)  # f-strings are not supported.
         and value not in expected_type.__args__
     ):
@@ -627,7 +632,7 @@ def validate_parameter_literals(func):
         annotations = {param[0]: param[1].annotation for param in func_params}
 
         # validate args
-        for param, arg in zip(annotations, args):
+        for param, arg in zip(annotations, args, strict=False):
             if annotations[param] is inspect.Parameter.empty:
                 continue
             validate_literal(param, arg, annotations[param], func.__name__)

reflex/{ivars → vars}/__init__.py

@@ -1,8 +1,12 @@
-"""Experimental Immutable-Based Var System."""
+"""Immutable-Based Var System."""
 
-from .base import ImmutableVar as ImmutableVar
 from .base import LiteralVar as LiteralVar
+from .base import Var as Var
+from .base import VarData as VarData
+from .base import get_unique_variable_name as get_unique_variable_name
+from .base import get_uuid_string_var as get_uuid_string_var
 from .base import var_operation as var_operation
+from .base import var_operation_return as var_operation_return
 from .function import FunctionStringVar as FunctionStringVar
 from .function import FunctionVar as FunctionVar
 from .function import VarOperationCall as VarOperationCall