reflex 0.6.3a4__py3-none-any.whl → 0.6.4__py3-none-any.whl

reflex/vars/function.py

@@ -4,21 +4,20 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import Any, Callable, ClassVar, Optional, Tuple, Type, Union
+from typing import Any, Callable, Optional, Tuple, Type, Union
 
 from reflex.utils.types import GenericType
 
 from .base import (
     CachedVarOperation,
     LiteralVar,
-    ToOperation,
     Var,
     VarData,
     cached_property_no_lock,
 )
 
 
-class FunctionVar(Var[Callable]):
+class FunctionVar(Var[Callable], python_types=Callable):
     """Base class for immutable function vars."""
 
     def __call__(self, *args: Var | Any) -> ArgsFunctionOperation:
@@ -180,17 +179,8 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
         )
 
 
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
-)
-class ToFunctionOperation(ToOperation, FunctionVar):
-    """Base class of converting a var to a function."""
-
-    _original: Var = dataclasses.field(default_factory=lambda: LiteralVar.create(None))
-
-    _default_var_type: ClassVar[GenericType] = Callable
-
-
 JSON_STRINGIFY = FunctionStringVar.create("JSON.stringify")
+ARRAY_ISARRAY = FunctionStringVar.create("Array.isArray")
+PROTOTYPE_TO_STRING = FunctionStringVar.create(
+    "((__to_string) => __to_string.toString())"
+)

reflex/vars/number.py

@@ -10,7 +10,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ClassVar,
     NoReturn,
     Type,
     TypeVar,
@@ -25,9 +24,7 @@ from reflex.utils.types import is_optional
 
 from .base import (
     CustomVarOperationReturn,
-    LiteralNoneVar,
     LiteralVar,
-    ToOperation,
     Var,
     VarData,
     unionize,
@@ -58,7 +55,7 @@ def raise_unsupported_operand_types(
     )
 
 
-class NumberVar(Var[NUMBER_T]):
+class NumberVar(Var[NUMBER_T], python_types=(int, float)):
     """Base class for immutable number vars."""
 
     @overload
@@ -760,7 +757,7 @@ def number_trunc_operation(value: NumberVar):
     return var_operation_return(js_expression=f"Math.trunc({value})", var_type=int)
 
 
-class BooleanVar(NumberVar[bool]):
+class BooleanVar(NumberVar[bool], python_types=bool):
     """Base class for immutable boolean vars."""
 
     def __invert__(self):
@@ -989,18 +986,25 @@ def boolean_not_operation(value: BooleanVar):
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class LiteralBooleanVar(LiteralVar, BooleanVar):
-    """Base class for immutable literal boolean vars."""
+class LiteralNumberVar(LiteralVar, NumberVar):
+    """Base class for immutable literal number vars."""
 
-    _var_value: bool = dataclasses.field(default=False)
+    _var_value: float | int = dataclasses.field(default=0)
 
     def json(self) -> str:
         """Get the JSON representation of the var.
 
         Returns:
             The JSON representation of the var.
+
+        Raises:
+            PrimitiveUnserializableToJSON: If the var is unserializable to JSON.
         """
-        return "true" if self._var_value else "false"
+        if math.isinf(self._var_value) or math.isnan(self._var_value):
+            raise PrimitiveUnserializableToJSON(
+                f"No valid JSON representation for {self}"
+            )
+        return json.dumps(self._var_value)
 
     def __hash__(self) -> int:
         """Calculate the hash value of the object.
@@ -1011,19 +1015,26 @@ class LiteralBooleanVar(LiteralVar, BooleanVar):
         return hash((self.__class__.__name__, self._var_value))
 
     @classmethod
-    def create(cls, value: bool, _var_data: VarData | None = None):
-        """Create the boolean var.
+    def create(cls, value: float | int, _var_data: VarData | None = None):
+        """Create the number var.
 
         Args:
             value: The value of the var.
             _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
-            The boolean var.
+            The number var.
         """
+        if math.isinf(value):
+            js_expr = "Infinity" if value > 0 else "-Infinity"
+        elif math.isnan(value):
+            js_expr = "NaN"
+        else:
+            js_expr = str(value)
+
         return cls(
-            _js_expr="true" if value else "false",
-            _var_type=bool,
+            _js_expr=js_expr,
+            _var_type=type(value),
             _var_data=_var_data,
             _var_value=value,
         )
@@ -1034,25 +1045,18 @@ class LiteralBooleanVar(LiteralVar, BooleanVar):
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class LiteralNumberVar(LiteralVar, NumberVar):
-    """Base class for immutable literal number vars."""
+class LiteralBooleanVar(LiteralVar, BooleanVar):
+    """Base class for immutable literal boolean vars."""
 
-    _var_value: float | int = dataclasses.field(default=0)
+    _var_value: bool = dataclasses.field(default=False)
 
     def json(self) -> str:
         """Get the JSON representation of the var.
 
         Returns:
             The JSON representation of the var.
-
-        Raises:
-            PrimitiveUnserializableToJSON: If the var is unserializable to JSON.
         """
-        if math.isinf(self._var_value) or math.isnan(self._var_value):
-            raise PrimitiveUnserializableToJSON(
-                f"No valid JSON representation for {self}"
-            )
-        return json.dumps(self._var_value)
+        return "true" if self._var_value else "false"
 
     def __hash__(self) -> int:
         """Calculate the hash value of the object.
@@ -1063,26 +1067,19 @@ class LiteralNumberVar(LiteralVar, NumberVar):
         return hash((self.__class__.__name__, self._var_value))
 
     @classmethod
-    def create(cls, value: float | int, _var_data: VarData | None = None):
-        """Create the number var.
+    def create(cls, value: bool, _var_data: VarData | None = None):
+        """Create the boolean var.
 
         Args:
             value: The value of the var.
             _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
-            The number var.
+            The boolean var.
         """
-        if math.isinf(value):
-            js_expr = "Infinity" if value > 0 else "-Infinity"
-        elif math.isnan(value):
-            js_expr = "NaN"
-        else:
-            js_expr = str(value)
-
         return cls(
-            _js_expr=js_expr,
-            _var_type=type(value),
+            _js_expr="true" if value else "false",
+            _var_type=bool,
             _var_data=_var_data,
             _var_value=value,
         )
@@ -1092,34 +1089,8 @@ number_types = Union[NumberVar, int, float]
 boolean_types = Union[BooleanVar, bool]
 
 
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
-)
-class ToNumberVarOperation(ToOperation, NumberVar):
-    """Base class for immutable number vars that are the result of a number operation."""
-
-    _original: Var = dataclasses.field(default_factory=lambda: LiteralNoneVar.create())
-
-    _default_var_type: ClassVar[Type] = float
-
-
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
-)
-class ToBooleanVarOperation(ToOperation, BooleanVar):
-    """Base class for immutable boolean vars that are the result of a boolean operation."""
-
-    _original: Var = dataclasses.field(default_factory=lambda: LiteralNoneVar.create())
-
-    _default_var_type: ClassVar[Type] = bool
-
-
 _IS_TRUE_IMPORT: ImportDict = {
-    f"/{Dirs.STATE_PATH}": [ImportVar(tag="isTrue")],
+    f"$/{Dirs.STATE_PATH}": [ImportVar(tag="isTrue")],
 }
 
 
@@ -1140,8 +1111,12 @@ def boolify(value: Var):
     )
 
 
+T = TypeVar("T")
+U = TypeVar("U")
+
+
 @var_operation
-def ternary_operation(condition: BooleanVar, if_true: Var, if_false: Var):
+def ternary_operation(condition: BooleanVar, if_true: Var[T], if_false: Var[U]):
     """Create a ternary operation.
 
     Args:
@@ -1152,10 +1127,14 @@ def ternary_operation(condition: BooleanVar, if_true: Var, if_false: Var):
     Returns:
         The ternary operation.
     """
-    return var_operation_return(
+    type_value: Union[Type[T], Type[U]] = unionize(
+        if_true._var_type, if_false._var_type
+    )
+    value: CustomVarOperationReturn[Union[T, U]] = var_operation_return(
         js_expression=f"({condition} ? {if_true} : {if_false})",
-        var_type=unionize(if_true._var_type, if_false._var_type),
+        var_type=type_value,
     )
+    return value
 
 
 NUMBER_TYPES = (int, float, NumberVar)

reflex/vars/object.py

@@ -8,7 +8,6 @@ import typing
 from inspect import isclass
 from typing import (
     Any,
-    ClassVar,
     Dict,
     List,
     NoReturn,
@@ -27,7 +26,6 @@ from reflex.utils.types import GenericType, get_attribute_access_type, get_origi
 from .base import (
     CachedVarOperation,
     LiteralVar,
-    ToOperation,
     Var,
     VarData,
     cached_property_no_lock,
@@ -48,7 +46,7 @@ ARRAY_INNER_TYPE = TypeVar("ARRAY_INNER_TYPE")
 OTHER_KEY_TYPE = TypeVar("OTHER_KEY_TYPE")
 
 
-class ObjectVar(Var[OBJECT_TYPE]):
+class ObjectVar(Var[OBJECT_TYPE], python_types=dict):
     """Base class for immutable object vars."""
 
     def _key_type(self) -> Type:
@@ -521,34 +519,6 @@ class ObjectItemOperation(CachedVarOperation, Var):
         )
 
 
-@dataclasses.dataclass(
-    eq=False,
-    frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
-)
-class ToObjectOperation(ToOperation, ObjectVar):
-    """Operation to convert a var to an object."""
-
-    _original: Var = dataclasses.field(
-        default_factory=lambda: LiteralObjectVar.create({})
-    )
-
-    _default_var_type: ClassVar[GenericType] = dict
-
-    def __getattr__(self, name: str) -> Any:
-        """Get an attribute of the var.
-
-        Args:
-            name: The name of the attribute.
-
-        Returns:
-            The attribute of the var.
-        """
-        if name == "_js_expr":
-            return self._original._js_expr
-        return ObjectVar.__getattr__(self, name)
-
-
 @var_operation
 def object_has_own_property_operation(object: ObjectVar, key: Var):
     """Check if an object has a key.