reflex 0.6.0__py3-none-any.whl → 0.6.0a1__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.utils.console import deprecate
+from reflex.vars import Var
 
 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 | Var,
-    match_cases: List[List[Var]],
-    default: Var,
+    cond: str | ImmutableVar,
+    match_cases: List[List[ImmutableVar]],
+    default: ImmutableVar,
 ) -> str:
     """Format a match expression whose return type is a Var.
 
@@ -332,7 +332,7 @@ def format_match(
 
 
 def format_prop(
-    prop: Union[Var, EventChain, ComponentStyle, str],
+    prop: Union[ImmutableVar, 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, Var):
+        if isinstance(prop, ImmutableVar):
             return str(prop)
 
         # Handle event props.
@@ -406,15 +406,26 @@ def format_props(*single_props, **key_value_props) -> list[str]:
         The formatted props list.
     """
     # Format all the props.
-    from reflex.vars.base import LiteralVar, Var
+    from reflex.ivars.base import ImmutableVar, LiteralVar
 
     return [
         (
-            f"{name}={{{format_prop(prop if isinstance(prop, Var) else LiteralVar.create(prop))}}}"
+            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))}}}"
+            )
         )
         for name, prop in sorted(key_value_props.items())
         if prop is not None
-    ] + [(f"{str(LiteralVar.create(prop))}") for prop in single_props]
+    ] + [
+        (
+            str(prop)
+            if isinstance(prop, ImmutableVar) and not isinstance(prop, ImmutableVar)
+            else f"{str(LiteralVar.create(prop))}"
+        )
+        for prop in single_props
+    ]
 
 
 def get_event_handler_parts(handler: EventHandler) -> tuple[str, str]:
@@ -475,10 +486,10 @@ def format_event(event_spec: EventSpec) -> str:
         [
             ":".join(
                 (
-                    name._js_expr,
+                    name._var_name,
                     (
                         wrap(
-                            json.dumps(val._js_expr).strip('"').replace("`", "\\`"),
+                            json.dumps(val._var_name).strip('"').replace("`", "\\`"),
                             "`",
                         )
                         if val._var_is_string
@@ -500,38 +511,7 @@ def format_event(event_spec: EventSpec) -> str:
 
 
 if TYPE_CHECKING:
-    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)
+    from reflex.ivars import ImmutableVar
 
 
 def format_queue_events(
@@ -543,7 +523,7 @@ def format_queue_events(
         | None
     ) = None,
     args_spec: Optional[ArgsSpec] = None,
-) -> Var[EventChain]:
+) -> ImmutableVar[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
@@ -569,10 +549,10 @@ def format_queue_events(
         call_event_fn,
         call_event_handler,
     )
-    from reflex.vars import FunctionVar, Var
+    from reflex.ivars import FunctionVar, ImmutableVar
 
     if not events:
-        return Var("(() => null)").to(FunctionVar, EventChain)  # type: ignore
+        return ImmutableVar("(() => null)").to(FunctionVar, EventChain)  # type: ignore
 
     # If no spec is provided, the function will take no arguments.
     def _default_args_spec():
@@ -597,7 +577,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, Var):
+            if isinstance(specs, ImmutableVar):
                 raise ValueError(
                     f"Invalid event spec: {specs}. Expected a list of EventSpecs."
                 )
@@ -605,7 +585,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 Var(
+    return ImmutableVar(
         f"{arg_def} => {{queueEvents([{','.join(payloads)}], {constants.CompileVars.SOCKET}); "
         f"processEvent({constants.CompileVars.SOCKET})}}",
     ).to(FunctionVar, EventChain)  # type: ignore
@@ -747,7 +727,7 @@ def collect_form_dict_names(form_dict: dict[str, Any]) -> dict[str, Any]:
     return collapsed
 
 
-def format_array_ref(refs: str, idx: Var | None) -> str:
+def format_array_ref(refs: str, idx: ImmutableVar | None) -> str:
     """Format a ref accessed by array.
 
     Args:
@@ -776,7 +756,7 @@ def format_data_editor_column(col: str | dict):
     Returns:
         The formatted column.
     """
-    from reflex.vars import Var
+    from reflex.ivars import ImmutableVar
 
     if isinstance(col, str):
         return {"title": col, "id": col.lower(), "type": "str"}
@@ -790,7 +770,7 @@ def format_data_editor_column(col: str | dict):
             col["overlayIcon"] = None
         return col
 
-    if isinstance(col, Var):
+    if isinstance(col, ImmutableVar):
         return col
 
     raise ValueError(
@@ -807,9 +787,9 @@ def format_data_editor_cell(cell: Any):
     Returns:
         The formatted cell.
     """
-    from reflex.vars.base import Var
+    from reflex.ivars.base import ImmutableVar
 
     return {
-        "kind": Var(_js_expr="GridCellKind.Text"),
+        "kind": ImmutableVar.create("GridCellKind.Text"),
         "data": cell,
     }

reflex/utils/imports.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-import dataclasses
 from collections import defaultdict
-from typing import DefaultDict, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
+
+from reflex.base import Base
 
 
 def merge_imports(
@@ -18,22 +19,12 @@ def merge_imports(
     Returns:
         The merged import dicts.
     """
-    all_imports: DefaultDict[str, List[ImportVar]] = defaultdict(list)
+    all_imports = defaultdict(list)
     for import_dict in imports:
         for lib, fields in (
             import_dict if isinstance(import_dict, tuple) else import_dict.items()
         ):
-            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
-                )
+            all_imports[lib].extend(fields)
     return all_imports
 
 
@@ -84,8 +75,7 @@ def collapse_imports(
     }
 
 
-@dataclasses.dataclass(order=True, frozen=True)
-class ImportVar:
+class ImportVar(Base):
     """An import var."""
 
     # The name of the import tag.
@@ -121,6 +111,73 @@ class ImportVar:
         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,7 +2,6 @@
 
 from __future__ import annotations
 
-import dataclasses
 import functools
 import glob
 import importlib
@@ -33,6 +32,7 @@ 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,8 +42,7 @@ from reflex.utils.registry import _get_best_registry
 CURRENTLY_INSTALLING_NODE = False
 
 
-@dataclasses.dataclass(frozen=True)
-class Template:
+class Template(Base):
     """A template for a Reflex app."""
 
     name: str
@@ -52,8 +51,7 @@ class Template:
     demo_url: str
 
 
-@dataclasses.dataclass(frozen=True)
-class CpuInfo:
+class CpuInfo(Base):
     """Model to save cpu info."""
 
     manufacturer_id: Optional[str]
@@ -73,18 +71,6 @@ def get_web_dir() -> Path:
     return workdir
 
 
-def _python_version_check():
-    """Emit deprecation warning for deprecated python versions."""
-    # Check for end-of-life python versions.
-    if sys.version_info < (3, 10):
-        console.deprecate(
-            feature_name="Support for Python 3.9 and older",
-            reason="please upgrade to Python 3.10 or newer",
-            deprecation_version="0.6.0",
-            removal_version="0.7.0",
-        )
-
-
 def check_latest_package_version(package_name: str):
     """Check if the latest version of the package is installed.
 
@@ -97,16 +83,15 @@ def check_latest_package_version(package_name: str):
         url = f"https://pypi.org/pypi/{package_name}/json"
         response = net.get(url)
         latest_version = response.json()["info"]["version"]
-        if get_or_set_last_reflex_version_check_datetime():
-            # Versions were already checked and saved in reflex.json, no need to warn again
-            return
-        if version.parse(current_version) < version.parse(latest_version):
-            # Show a warning when the host version is older than PyPI version
+        if (
+            version.parse(current_version) < version.parse(latest_version)
+            and not get_or_set_last_reflex_version_check_datetime()
+        ):
+            # only show a warning when the host version is outdated and
+            # the last_version_check_datetime is not set in reflex.json
             console.warn(
                 f"Your version ({current_version}) of {package_name} is out of date. Upgrade to {latest_version} with 'pip install {package_name} --upgrade'"
             )
-        # Check for depreacted python versions
-        _python_version_check()
     except Exception:
         pass
 
@@ -303,7 +288,7 @@ def get_compiled_app(reload: bool = False, export: bool = False) -> ModuleType:
     """
     app_module = get_app(reload=reload)
     app = getattr(app_module, constants.CompileVars.APP)
-    # For py3.9 compatibility when redis is used, we MUST add any decorator pages
+    # For py3.8 and py3.9 compatibility when redis is used, we MUST add any decorator pages
     # before compiling the app in a thread to avoid event loop error (REF-2172).
     app._apply_decorated_pages()
     app._compile(export=export)
@@ -1292,16 +1277,11 @@ def fetch_app_templates(version: str) -> dict[str, Template]:
             ),
             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
+    return {
+        tp["name"]: Template.parse_obj(tp)
+        for tp in templates_data
+        if not tp["hidden"] and tp["code_url"] is not None
+    }
 
 
 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,10 +69,11 @@ 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.vars.base": ["Var"],
+    "reflex.ivars.base": ["ImmutableVar"],
 }
 
 
@@ -150,7 +151,7 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
 
     if args:
         inner_container_type_args = (
-            sorted((repr(arg) for arg in args))
+            [repr(arg) for arg in args]
             if rx_types.is_literal(value)
             else [
                 _get_type_hint(arg, type_hint_globals, is_optional=False)
@@ -184,7 +185,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(sorted(types))
+                res = ", ".join(types)
                 res = f"Union[{res}]"
     elif isinstance(value, str):
         ev = eval(value, type_hint_globals)
@@ -355,7 +356,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, Var):
+                    if isinstance(default, ImmutableVar):
                         default = default._decode()  # type: ignore
 
             kwargs.append(
@@ -433,7 +434,7 @@ def _generate_component_create_functiondef(
             ast.arg(
                 arg=trigger,
                 annotation=ast.Name(
-                    id="Optional[Union[EventHandler, EventSpec, list, Callable, Var]]"
+                    id="Optional[Union[EventHandler, EventSpec, list, Callable, ImmutableVar]]"
                 ),
             ),
             ast.Constant(value=None),
@@ -902,13 +903,7 @@ 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 "  # noqa"  # ignore ruff formatting here for cases like rx.list.
-                    if isinstance(mod, tuple)
-                    else ""
-                )
+                + ("  # type: ignore" if mod in pyright_ignore_imports else "")
                 for mod, path in sub_mod_attrs.items()
             ]
             sub_mod_attrs_imports.append("")

reflex/utils/serializers.py

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

reflex/utils/telemetry.py

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

reflex/utils/types.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import contextlib
-import dataclasses
 import inspect
 import sys
 import types
@@ -96,7 +95,7 @@ PrimitiveType = Union[int, float, bool, str, list, dict, set, tuple]
 StateVar = Union[PrimitiveType, Base, None]
 StateIterVar = Union[list, set, tuple]
 
-# ArgsSpec = Callable[[Var], list[Var]]
+# ArgsSpec = Callable[[ImmutableVar], list[ImmutableVar]]
 ArgsSpec = Callable
 
 
@@ -481,11 +480,7 @@ 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_)
-        or dataclasses.is_dataclass(type_)
-    )
+    return _issubclass(type_, StateVar) or serializers.has_serializer(type_)
 
 
 def is_backend_base_variable(name: str, cls: Type) -> bool:
@@ -519,7 +514,7 @@ def is_backend_base_variable(name: str, cls: Type) -> bool:
     if name in cls.inherited_backend_vars:
         return False
 
-    from reflex.vars.base import is_computed_var
+    from reflex.ivars.base import is_computed_var
 
     if name in cls.__dict__:
         value = cls.__dict__[name]
@@ -595,11 +590,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.vars import Var
+    from reflex.ivars import ImmutableVar
 
     if (
         is_literal(expected_type)
-        and not isinstance(value, Var)  # validating vars is not supported yet.
+        and not isinstance(value, ImmutableVar)  # validating vars is not supported yet.
         and not is_encoded_fstring(value)  # f-strings are not supported.
         and value not in expected_type.__args__
     ):