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

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 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", "BaseVar", "ComputedVar"],
+    "reflex.vars": ["Var"],
     "reflex.components.core.breakpoints": ["Breakpoints"],
     "reflex.event": ["EventChain", "EventHandler", "EventSpec"],
     "reflex.style": ["Style"],
+    "reflex.ivars.base": ["ImmutableVar"],
 }
 
 
@@ -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, BaseVar]]"
+                    id="Optional[Union[EventHandler, EventSpec, list, Callable, ImmutableVar]]"
                 ),
             ),
             ast.Constant(value=None),

reflex/utils/serializers.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import functools
 import json
-import types as builtin_types
 import warnings
 from datetime import date, datetime, time, timedelta
 from enum import Enum
@@ -26,7 +25,7 @@ from typing import (
 
 from reflex.base import Base
 from reflex.constants.colors import Color, format_color
-from reflex.utils import exceptions, types
+from reflex.utils import types
 
 # Mapping from type to a serializer.
 # The serializer should convert the type to a JSON object.
@@ -250,7 +249,14 @@ def serialize_base(value: Base) -> str:
     Returns:
         The serialized Base.
     """
-    return value.json()
+    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
@@ -263,13 +269,9 @@ def serialize_list(value: Union[List, Tuple, Set]) -> str:
     Returns:
         The serialized list.
     """
-    from reflex.utils import format
+    from reflex.ivars import LiteralArrayVar
 
-    # Dump the list to a string.
-    fprop = format.json_dumps(list(value))
-
-    # Unwrap var values.
-    return format.unwrap_vars(fprop)
+    return str(LiteralArrayVar.create(value))
 
 
 @serializer
@@ -281,30 +283,10 @@ def serialize_dict(prop: Dict[str, Any]) -> str:
 
     Returns:
         The serialized dictionary.
-
-    Raises:
-        InvalidStylePropError: If the style prop is invalid.
     """
-    # Import here to avoid circular imports.
-    from reflex.event import EventHandler
-    from reflex.utils import format
-
-    prop_dict = {}
-
-    for key, value in prop.items():
-        if types._issubclass(type(value), Callable):
-            raise exceptions.InvalidStylePropError(
-                f"The style prop `{format.to_snake_case(key)}` cannot have "  # type: ignore
-                f"`{value.fn.__qualname__ if isinstance(value, EventHandler) else value.__qualname__ if isinstance(value, builtin_types.FunctionType) else value}`, "
-                f"an event handler or callable as its value"
-            )
-        prop_dict[key] = value
-
-    # Dump the dict to a string.
-    fprop = format.json_dumps(prop_dict)
+    from reflex.ivars import LiteralObjectVar
 
-    # Unwrap var values.
-    return format.unwrap_vars(fprop)
+    return str(LiteralObjectVar.create(prop))
 
 
 @serializer(to=str)

reflex/utils/types.py

@@ -6,7 +6,7 @@ import contextlib
 import inspect
 import sys
 import types
-from functools import cached_property, wraps
+from functools import cached_property, lru_cache, wraps
 from typing import (
     Any,
     Callable,
@@ -21,9 +21,11 @@ from typing import (
     Union,
     _GenericAlias,  # type: ignore
     get_args,
-    get_origin,
     get_type_hints,
 )
+from typing import (
+    get_origin as get_origin_og,
+)
 
 import sqlalchemy
 
@@ -93,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
 
 
@@ -109,6 +111,11 @@ RESERVED_BACKEND_VAR_NAMES = {
     "_was_touched",
 }
 
+if sys.version_info >= (3, 11):
+    from typing import Self as Self
+else:
+    from typing_extensions import Self as Self
+
 
 class Unset:
     """A class to represent an unset value.
@@ -133,6 +140,20 @@ class Unset:
         return False
 
 
+@lru_cache()
+def get_origin(tp):
+    """Get the origin of a class.
+
+    Args:
+        tp: The class to get the origin of.
+
+    Returns:
+        The origin of the class.
+    """
+    return get_origin_og(tp)
+
+
+@lru_cache()
 def is_generic_alias(cls: GenericType) -> bool:
     """Check whether the class is a generic alias.
 
@@ -157,6 +178,7 @@ def is_none(cls: GenericType) -> bool:
     return cls is type(None) or cls is None
 
 
+@lru_cache()
 def is_union(cls: GenericType) -> bool:
     """Check if a class is a Union.
 
@@ -169,6 +191,7 @@ def is_union(cls: GenericType) -> bool:
     return get_origin(cls) in UnionTypes
 
 
+@lru_cache()
 def is_literal(cls: GenericType) -> bool:
     """Check if a class is a Literal.
 
@@ -222,9 +245,14 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     """
     from reflex.model import Model
 
-    attr = getattr(cls, name, None)
+    try:
+        attr = getattr(cls, name, None)
+    except NotImplementedError:
+        attr = None
+
     if hint := get_property_hint(attr):
         return hint
+
     if (
         hasattr(cls, "__fields__")
         and name in cls.__fields__
@@ -314,6 +342,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     return None  # Attribute is not accessible.
 
 
+@lru_cache()
 def get_base_class(cls: GenericType) -> Type:
     """Get the base class of a class.
 
@@ -485,17 +514,23 @@ 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
+
     if name in cls.__dict__:
         value = cls.__dict__[name]
         if type(value) == classmethod:
             return False
         if callable(value):
             return False
-        from reflex.vars import ComputedVar
 
         if isinstance(
-            value, (types.FunctionType, property, cached_property, ComputedVar)
-        ):
+            value,
+            (
+                types.FunctionType,
+                property,
+                cached_property,
+            ),
+        ) or is_computed_var(value):
             return False
 
     return True
@@ -555,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__
     ):