reflex 0.7.1a4__py3-none-any.whl → 0.7.2__py3-none-any.whl

reflex/vars/function.py

@@ -9,14 +9,11 @@ from typing import (
     Callable,
     Concatenate,
     Generic,
-    Optional,
     ParamSpec,
     Protocol,
     Sequence,
-    Tuple,
     Type,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -56,52 +53,52 @@ class FunctionVar(Var[CALLABLE_TYPE], default_type=ReflexCallable[Any, Any]):
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, P], R]],
-        arg1: Union[V1, Var[V1]],
+        arg1: V1 | Var[V1],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, V2, P], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, V2, V3, P], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, V2, V3, V4, P], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, V2, V3, V4, V5, P], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
-        arg5: Union[V5, Var[V5]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
+        arg5: V5 | Var[V5],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
     def partial(
         self: FunctionVar[ReflexCallable[Concatenate[V1, V2, V3, V4, V5, V6, P], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
-        arg5: Union[V5, Var[V5]],
-        arg6: Union[V6, Var[V6]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
+        arg5: V5 | Var[V5],
+        arg6: V6 | Var[V6],
     ) -> FunctionVar[ReflexCallable[P, R]]: ...
 
     @overload
@@ -130,52 +127,52 @@ class FunctionVar(Var[CALLABLE_TYPE], default_type=ReflexCallable[Any, Any]):
 
     @overload
     def call(
-        self: FunctionVar[ReflexCallable[[V1], R]], arg1: Union[V1, Var[V1]]
+        self: FunctionVar[ReflexCallable[[V1], R]], arg1: V1 | Var[V1]
     ) -> VarOperationCall[[V1], R]: ...
 
     @overload
     def call(
         self: FunctionVar[ReflexCallable[[V1, V2], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
     ) -> VarOperationCall[[V1, V2], R]: ...
 
     @overload
     def call(
         self: FunctionVar[ReflexCallable[[V1, V2, V3], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
     ) -> VarOperationCall[[V1, V2, V3], R]: ...
 
     @overload
     def call(
         self: FunctionVar[ReflexCallable[[V1, V2, V3, V4], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
     ) -> VarOperationCall[[V1, V2, V3, V4], R]: ...
 
     @overload
     def call(
         self: FunctionVar[ReflexCallable[[V1, V2, V3, V4, V5], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
-        arg5: Union[V5, Var[V5]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
+        arg5: V5 | Var[V5],
     ) -> VarOperationCall[[V1, V2, V3, V4, V5], R]: ...
 
     @overload
     def call(
         self: FunctionVar[ReflexCallable[[V1, V2, V3, V4, V5, V6], R]],
-        arg1: Union[V1, Var[V1]],
-        arg2: Union[V2, Var[V2]],
-        arg3: Union[V3, Var[V3]],
-        arg4: Union[V4, Var[V4]],
-        arg5: Union[V5, Var[V5]],
-        arg6: Union[V6, Var[V6]],
+        arg1: V1 | Var[V1],
+        arg2: V2 | Var[V2],
+        arg3: V3 | Var[V3],
+        arg4: V4 | Var[V4],
+        arg5: V5 | Var[V5],
+        arg6: V6 | Var[V6],
     ) -> VarOperationCall[[V1, V2, V3, V4, V5, V6], R]: ...
 
     @overload
@@ -243,8 +240,8 @@ class FunctionStringVar(FunctionVar[CALLABLE_TYPE]):
 class VarOperationCall(Generic[P, R], CachedVarOperation, Var[R]):
     """Base class for immutable vars that are the result of a function call."""
 
-    _func: Optional[FunctionVar[ReflexCallable[P, R]]] = dataclasses.field(default=None)
-    _args: Tuple[Union[Var, Any], ...] = dataclasses.field(default_factory=tuple)
+    _func: FunctionVar[ReflexCallable[P, R]] | None = dataclasses.field(default=None)
+    _args: tuple[Var | Any, ...] = dataclasses.field(default_factory=tuple)
 
     @cached_property_no_lock
     def _cached_var_name(self) -> str:
@@ -306,8 +303,8 @@ class VarOperationCall(Generic[P, R], CachedVarOperation, Var[R]):
 class DestructuredArg:
     """Class for destructured arguments."""
 
-    fields: Tuple[str, ...] = ()
-    rest: Optional[str] = None
+    fields: tuple[str, ...] = ()
+    rest: str | None = None
 
     def to_javascript(self) -> str:
         """Convert the destructured argument to JavaScript.
@@ -328,8 +325,8 @@ class DestructuredArg:
 class FunctionArgs:
     """Class for function arguments."""
 
-    args: Tuple[Union[str, DestructuredArg], ...] = ()
-    rest: Optional[str] = None
+    args: tuple[str | DestructuredArg, ...] = ()
+    rest: str | None = None
 
 
 def format_args_function_operation(
@@ -368,7 +365,7 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
     """Base class for immutable function defined via arguments and return expression."""
 
     _args: FunctionArgs = dataclasses.field(default_factory=FunctionArgs)
-    _return_expr: Union[Var, Any] = dataclasses.field(default=None)
+    _return_expr: Var | Any = dataclasses.field(default=None)
     _explicit_return: bool = dataclasses.field(default=False)
 
     @cached_property_no_lock
@@ -385,7 +382,7 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
     @classmethod
     def create(
         cls,
-        args_names: Sequence[Union[str, DestructuredArg]],
+        args_names: Sequence[str | DestructuredArg],
         return_expr: Var | Any,
         rest: str | None = None,
         explicit_return: bool = False,
@@ -425,7 +422,7 @@ class ArgsFunctionOperationBuilder(CachedVarOperation, BuilderFunctionVar):
     """Base class for immutable function defined via arguments and return expression with the builder pattern."""
 
     _args: FunctionArgs = dataclasses.field(default_factory=FunctionArgs)
-    _return_expr: Union[Var, Any] = dataclasses.field(default=None)
+    _return_expr: Var | Any = dataclasses.field(default=None)
     _explicit_return: bool = dataclasses.field(default=False)
 
     @cached_property_no_lock
@@ -442,7 +439,7 @@ class ArgsFunctionOperationBuilder(CachedVarOperation, BuilderFunctionVar):
     @classmethod
     def create(
         cls,
-        args_names: Sequence[Union[str, DestructuredArg]],
+        args_names: Sequence[str | DestructuredArg],
         return_expr: Var | Any,
         rest: str | None = None,
         explicit_return: bool = False,

reflex/vars/number.py

@@ -17,7 +17,11 @@ from typing import (
 )
 
 from reflex.constants.base import Dirs
-from reflex.utils.exceptions import PrimitiveUnserializableToJSONError, VarTypeError
+from reflex.utils.exceptions import (
+    PrimitiveUnserializableToJSONError,
+    VarTypeError,
+    VarValueError,
+)
 from reflex.utils.imports import ImportDict, ImportVar
 
 from .base import (
@@ -530,6 +534,56 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         return issubclass(self._var_type, int)
 
+    def __format__(self, format_spec: str) -> str:
+        """Format the number.
+
+        Args:
+            format_spec: The format specifier.
+
+        Returns:
+            The formatted number.
+
+        Raises:
+            VarValueError: If the format specifier is not supported.
+        """
+        if (
+            format_spec
+            and format_spec[-1] == "f"
+            and format_spec[0] == "."
+            and format_spec[1:-1].isdigit()
+        ):
+            how_many_decimals = int(format_spec[1:-1])
+            return (
+                f"{get_decimal_string_operation(self, Var.create(how_many_decimals))}"
+            )
+
+        if format_spec:
+            raise VarValueError(
+                (
+                    "Unknown format code '{}' for object of type 'NumberVar'. It is only supported to use '.f' for float numbers."
+                    "If possible, use computed variables instead: https://reflex.dev/docs/vars/computed-vars/"
+                ).format(format_spec)
+            )
+
+        return super().__format__(format_spec)
+
+
+@var_operation
+def get_decimal_string_operation(value: NumberVar, decimals: NumberVar):
+    """Get the decimal string of the number.
+
+    Args:
+        value: The number.
+        decimals: The number of decimals.
+
+    Returns:
+        The decimal string of the number.
+    """
+    return var_operation_return(
+        js_expression=f"({value}.toFixed({decimals}))",
+        var_type=str,
+    )
+
 
 def binary_number_operation(
     func: Callable[[NumberVar, NumberVar], str],
@@ -1073,8 +1127,8 @@ class LiteralBooleanVar(LiteralVar, BooleanVar):
         )
 
 
-number_types = Union[NumberVar, int, float]
-boolean_types = Union[BooleanVar, bool]
+number_types = NumberVar | int | float
+boolean_types = BooleanVar | bool
 
 
 _IS_TRUE_IMPORT: ImportDict = {
@@ -1106,7 +1160,7 @@ U = TypeVar("U")
 @var_operation
 def ternary_operation(
     condition: BooleanVar, if_true: Var[T], if_false: Var[U]
-) -> CustomVarOperationReturn[Union[T, U]]:
+) -> CustomVarOperationReturn[T | U]:
     """Create a ternary operation.
 
     Args:
@@ -1120,7 +1174,7 @@ def ternary_operation(
     type_value: Union[Type[T], Type[U]] = unionize(
         if_true._var_type, if_false._var_type
     )
-    value: CustomVarOperationReturn[Union[T, U]] = var_operation_return(
+    value: CustomVarOperationReturn[T | U] = var_operation_return(
         js_expression=f"({condition} ? {if_true} : {if_false})",
         var_type=type_value,
     )

reflex/vars/object.py

@@ -2,19 +2,18 @@
 
 from __future__ import annotations
 
+import collections.abc
 import dataclasses
 import typing
 from inspect import isclass
 from typing import (
     Any,
-    List,
     Mapping,
     NoReturn,
-    Tuple,
     Type,
     TypeVar,
-    Union,
     get_args,
+    get_type_hints,
     overload,
 )
 
@@ -27,6 +26,7 @@ from reflex.utils.types import (
     get_attribute_access_type,
     get_origin,
     safe_issubclass,
+    unionize,
 )
 
 from .base import (
@@ -52,6 +52,29 @@ ARRAY_INNER_TYPE = TypeVar("ARRAY_INNER_TYPE")
 OTHER_KEY_TYPE = TypeVar("OTHER_KEY_TYPE")
 
 
+def _determine_value_type(var_type: GenericType):
+    origin_var_type = get_origin(var_type) or var_type
+
+    if origin_var_type in types.UnionTypes:
+        return unionize(
+            *[
+                _determine_value_type(arg)
+                for arg in get_args(var_type)
+                if arg is not type(None)
+            ]
+        )
+
+    if is_typeddict(origin_var_type) or dataclasses.is_dataclass(origin_var_type):
+        annotations = get_type_hints(origin_var_type)
+        return unionize(*annotations.values())
+
+    if origin_var_type in [dict, Mapping, collections.abc.Mapping]:
+        args = get_args(var_type)
+        return args[1] if args else Any
+
+    return Any
+
+
 class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
     """Base class for immutable object vars."""
 
@@ -69,21 +92,17 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
     ) -> Type[VALUE_TYPE]: ...
 
     @overload
-    def _value_type(self) -> Type: ...
+    def _value_type(self) -> GenericType: ...
 
-    def _value_type(self) -> Type:
+    def _value_type(self) -> GenericType:
         """Get the type of the values of the object.
 
         Returns:
             The type of the values of the object.
         """
-        fixed_type = get_origin(self._var_type) or self._var_type
-        if not isclass(fixed_type):
-            return Any  # pyright: ignore [reportReturnType]
-        args = get_args(self._var_type) if issubclass(fixed_type, Mapping) else ()
-        return args[1] if args else Any  # pyright: ignore [reportReturnType]
+        return _determine_value_type(self._var_type)
 
-    def keys(self) -> ArrayVar[List[str]]:
+    def keys(self) -> ArrayVar[list[str]]:
         """Get the keys of the object.
 
         Returns:
@@ -94,7 +113,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
     @overload
     def values(
         self: ObjectVar[Mapping[Any, VALUE_TYPE]],
-    ) -> ArrayVar[List[VALUE_TYPE]]: ...
+    ) -> ArrayVar[list[VALUE_TYPE]]: ...
 
     @overload
     def values(self) -> ArrayVar: ...
@@ -110,7 +129,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
     @overload
     def entries(
         self: ObjectVar[Mapping[Any, VALUE_TYPE]],
-    ) -> ArrayVar[List[Tuple[str, VALUE_TYPE]]]: ...
+    ) -> ArrayVar[list[tuple[str, VALUE_TYPE]]]: ...
 
     @overload
     def entries(self) -> ArrayVar: ...
@@ -266,8 +285,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
 
         var_type = self._var_type
 
-        if types.is_optional(var_type):
-            var_type = get_args(var_type)[0]
+        var_type = types.value_inside_optional(var_type)
 
         fixed_type = get_origin(var_type) or var_type
 
@@ -306,9 +324,7 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
 class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
     """Base class for immutable literal object vars."""
 
-    _var_value: Mapping[Union[Var, Any], Union[Var, Any]] = dataclasses.field(
-        default_factory=dict
-    )
+    _var_value: Mapping[Var | Any, Var | Any] = dataclasses.field(default_factory=dict)
 
     def _key_type(self) -> Type:
         """Get the type of the keys of the object.
@@ -425,9 +441,14 @@ def object_keys_operation(value: ObjectVar):
     Returns:
         The keys of the object.
     """
+    if not types.is_optional(value._var_type):
+        return var_operation_return(
+            js_expression=f"Object.keys({value})",
+            var_type=list[str],
+        )
     return var_operation_return(
-        js_expression=f"Object.keys({value})",
-        var_type=List[str],
+        js_expression=f"((value) => value ?? undefined === undefined ? undefined : Object.keys(value))({value})",
+        var_type=(list[str] | None),
     )
 
 
@@ -441,9 +462,14 @@ def object_values_operation(value: ObjectVar):
     Returns:
         The values of the object.
     """
+    if not types.is_optional(value._var_type):
+        return var_operation_return(
+            js_expression=f"Object.values({value})",
+            var_type=list[value._value_type()],
+        )
     return var_operation_return(
-        js_expression=f"Object.values({value})",
-        var_type=List[value._value_type()],
+        js_expression=f"((value) => value ?? undefined === undefined ? undefined : Object.values(value))({value})",
+        var_type=(list[value._value_type()] | None),
     )
 
 
@@ -457,9 +483,14 @@ def object_entries_operation(value: ObjectVar):
     Returns:
         The entries of the object.
     """
+    if not types.is_optional(value._var_type):
+        return var_operation_return(
+            js_expression=f"Object.entries({value})",
+            var_type=list[tuple[str, value._value_type()]],
+        )
     return var_operation_return(
-        js_expression=f"Object.entries({value})",
-        var_type=List[Tuple[str, value._value_type()]],
+        js_expression=f"((value) => value ?? undefined === undefined ? undefined : Object.entries(value))({value})",
+        var_type=(list[tuple[str, value._value_type()]] | None),
     )
 
 
@@ -477,8 +508,8 @@ def object_merge_operation(lhs: ObjectVar, rhs: ObjectVar):
     return var_operation_return(
         js_expression=f"({{...{lhs}, ...{rhs}}})",
         var_type=Mapping[
-            Union[lhs._key_type(), rhs._key_type()],
-            Union[lhs._value_type(), rhs._value_type()],
+            lhs._key_type() | rhs._key_type(),
+            lhs._value_type() | rhs._value_type(),
         ],
     )