reflex 0.6.4a2__py3-none-any.whl → 0.6.5__py3-none-any.whl

reflex/vars/base.py

@@ -38,13 +38,7 @@ from typing import (
     overload,
 )
 
-from typing_extensions import (
-    ParamSpec,
-    TypeGuard,
-    deprecated,
-    get_type_hints,
-    override,
-)
+from typing_extensions import ParamSpec, TypeGuard, deprecated, get_type_hints, override
 
 from reflex import constants
 from reflex.base import Base
@@ -63,16 +57,19 @@ from reflex.utils.imports import (
     ParsedImportDict,
     parse_imports,
 )
-from reflex.utils.types import GenericType, Self, get_origin, has_args, unionize
+from reflex.utils.types import (
+    GenericType,
+    Self,
+    _isinstance,
+    get_origin,
+    has_args,
+    unionize,
+)
 
 if TYPE_CHECKING:
     from reflex.state import BaseState
 
-    from .function import FunctionVar
-    from .number import (
-        BooleanVar,
-        NumberVar,
-    )
+    from .number import BooleanVar, NumberVar
     from .object import ObjectVar
     from .sequence import ArrayVar, StringVar
 
@@ -151,31 +148,41 @@ class VarData:
         """
         return dict((k, list(v)) for k, v in self.imports)
 
-    @classmethod
-    def merge(cls, *others: VarData | None) -> VarData | None:
+    def merge(*all: VarData | None) -> VarData | None:
         """Merge multiple var data objects.
 
         Args:
-            *others: The var data objects to merge.
+            *all: The var data objects to merge.
 
         Returns:
             The merged var data object.
+
+        # noqa: DAR102 *all
         """
-        state = ""
-        field_name = ""
-        _imports = {}
-        hooks = {}
-        for var_data in others:
-            if var_data is None:
-                continue
-            state = state or var_data.state
-            field_name = field_name or var_data.field_name
-            _imports = imports.merge_imports(_imports, var_data.imports)
-            hooks.update(
-                var_data.hooks
-                if isinstance(var_data.hooks, dict)
-                else {k: None for k in var_data.hooks}
-            )
+        all_var_datas = list(filter(None, all))
+
+        if not all_var_datas:
+            return None
+
+        if len(all_var_datas) == 1:
+            return all_var_datas[0]
+
+        # Get the first non-empty field name or default to empty string.
+        field_name = next(
+            (var_data.field_name for var_data in all_var_datas if var_data.field_name),
+            "",
+        )
+
+        # Get the first non-empty state or default to empty string.
+        state = next(
+            (var_data.state for var_data in all_var_datas if var_data.state), ""
+        )
+
+        hooks = {hook: None for var_data in all_var_datas for hook in var_data.hooks}
+
+        _imports = imports.merge_imports(
+            *(var_data.imports for var_data in all_var_datas)
+        )
 
         if state or _imports or hooks or field_name:
             return VarData(
@@ -184,6 +191,7 @@ class VarData:
                 imports=_imports,
                 hooks=hooks,
             )
+
         return None
 
     def __bool__(self) -> bool:
@@ -261,6 +269,24 @@ def _decode_var_immutable(value: str) -> tuple[VarData | None, str]:
     return VarData.merge(*var_datas) if var_datas else None, value
 
 
+def can_use_in_object_var(cls: GenericType) -> bool:
+    """Check if the class can be used in an ObjectVar.
+
+    Args:
+        cls: The class to check.
+
+    Returns:
+        Whether the class can be used in an ObjectVar.
+    """
+    if types.is_union(cls):
+        return all(can_use_in_object_var(t) for t in types.get_args(cls))
+    return (
+        inspect.isclass(cls)
+        and not issubclass(cls, Var)
+        and serializers.can_serialize(cls, dict)
+    )
+
+
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
@@ -547,36 +573,33 @@ class Var(Generic[VAR_TYPE]):
         # Encode the _var_data into the formatted output for tracking purposes.
         return f"{constants.REFLEX_VAR_OPENING_TAG}{hashed_var}{constants.REFLEX_VAR_CLOSING_TAG}{self._js_expr}"
 
-    @overload
-    def to(self, output: Type[StringVar]) -> StringVar: ...
-
     @overload
     def to(self, output: Type[str]) -> StringVar: ...
 
     @overload
-    def to(self, output: Type[BooleanVar]) -> BooleanVar: ...
+    def to(self, output: Type[bool]) -> BooleanVar: ...
 
     @overload
-    def to(
-        self, output: Type[NumberVar], var_type: type[int] | type[float] = float
-    ) -> NumberVar: ...
+    def to(self, output: type[int] | type[float]) -> NumberVar: ...
 
     @overload
     def to(
         self,
-        output: Type[ArrayVar],
-        var_type: type[list] | type[tuple] | type[set] = list,
+        output: type[list] | type[tuple] | type[set],
     ) -> ArrayVar: ...
 
     @overload
     def to(
-        self, output: Type[ObjectVar], var_type: types.GenericType = dict
-    ) -> ObjectVar: ...
+        self, output: Type[ObjectVar], var_type: Type[VAR_INSIDE]
+    ) -> ObjectVar[VAR_INSIDE]: ...
 
     @overload
     def to(
-        self, output: Type[FunctionVar], var_type: Type[Callable] = Callable
-    ) -> FunctionVar: ...
+        self, output: Type[ObjectVar], var_type: None = None
+    ) -> ObjectVar[VAR_TYPE]: ...
+
+    @overload
+    def to(self, output: VAR_SUBCLASS, var_type: None = None) -> VAR_SUBCLASS: ...
 
     @overload
     def to(
@@ -601,10 +624,6 @@ class Var(Generic[VAR_TYPE]):
         """
         from .object import ObjectVar
 
-        base_type = var_type
-        if types.is_optional(base_type):
-            base_type = types.get_args(base_type)[0]
-
         fixed_output_type = get_origin(output) or output
 
         # If the first argument is a python type, we map it to the corresponding Var type.
@@ -616,21 +635,19 @@ class Var(Generic[VAR_TYPE]):
             return get_to_operation(NoneVar).create(self)  # type: ignore
 
         # Handle fixed_output_type being Base or a dataclass.
-        try:
-            if issubclass(fixed_output_type, Base):
-                return self.to(ObjectVar, output)
-        except TypeError:
-            pass
-        if dataclasses.is_dataclass(fixed_output_type) and not issubclass(
-            fixed_output_type, Var
-        ):
+        if can_use_in_object_var(fixed_output_type):
             return self.to(ObjectVar, output)
 
         if inspect.isclass(output):
             for var_subclass in _var_subclasses[::-1]:
                 if issubclass(output, var_subclass.var_subclass):
+                    current_var_type = self._var_type
+                    if current_var_type is Any:
+                        new_var_type = var_type
+                    else:
+                        new_var_type = var_type or current_var_type
                     to_operation_return = var_subclass.to_var_subclass.create(
-                        value=self, _var_type=var_type
+                        value=self, _var_type=new_var_type
                     )
                     return to_operation_return  # type: ignore
 
@@ -693,11 +710,7 @@ class Var(Generic[VAR_TYPE]):
             ):
                 return self.to(NumberVar, self._var_type)
 
-            if all(
-                inspect.isclass(t)
-                and (issubclass(t, Base) or dataclasses.is_dataclass(t))
-                for t in inner_types
-            ):
+            if can_use_in_object_var(var_type):
                 return self.to(ObjectVar, self._var_type)
 
             return self
@@ -716,16 +729,12 @@ class Var(Generic[VAR_TYPE]):
             if issubclass(fixed_type, var_subclass.python_types):
                 return self.to(var_subclass.var_subclass, self._var_type)
 
-        try:
-            if issubclass(fixed_type, Base):
-                return self.to(ObjectVar, self._var_type)
-        except TypeError:
-            pass
-        if dataclasses.is_dataclass(fixed_type):
+        if can_use_in_object_var(fixed_type):
             return self.to(ObjectVar, self._var_type)
+
         return self
 
-    def get_default_value(self) -> Any:
+    def _get_default_value(self) -> Any:
         """Get the default value of the var.
 
         Returns:
@@ -768,7 +777,7 @@ class Var(Generic[VAR_TYPE]):
                 ) from e
         return set() if issubclass(type_, set) else None
 
-    def get_setter_name(self, include_state: bool = True) -> str:
+    def _get_setter_name(self, include_state: bool = True) -> str:
         """Get the name of the var's generated setter function.
 
         Args:
@@ -785,7 +794,7 @@ class Var(Generic[VAR_TYPE]):
             return setter
         return ".".join((var_data.state, setter))
 
-    def get_setter(self) -> Callable[[BaseState, Any], None]:
+    def _get_setter(self) -> Callable[[BaseState, Any], None]:
         """Get the var's setter function.
 
         Returns:
@@ -811,7 +820,7 @@ class Var(Generic[VAR_TYPE]):
             else:
                 setattr(state, actual_name, value)
 
-        setter.__qualname__ = self.get_setter_name()
+        setter.__qualname__ = self._get_setter_name()
 
         return setter
 
@@ -944,7 +953,7 @@ class Var(Generic[VAR_TYPE]):
             else PROTOTYPE_TO_STRING.call(self).to(StringVar)
         )
 
-    def as_ref(self) -> Var:
+    def _as_ref(self) -> Var:
         """Get a reference to the var.
 
         Returns:
@@ -989,7 +998,7 @@ class Var(Generic[VAR_TYPE]):
         type_of = FunctionStringVar("typeof")
         return type_of.call(self).to(StringVar)
 
-    def without_data(self):
+    def _without_data(self):
         """Create a copy of the var without the data.
 
         Returns:
@@ -997,20 +1006,6 @@ class Var(Generic[VAR_TYPE]):
         """
         return dataclasses.replace(self, _var_data=None)
 
-    def contains(self, value: Any = None, field: Any = None):
-        """Get an attribute of the var.
-
-        Args:
-            value: The value to check for.
-            field: The field to check for.
-
-        Raises:
-            TypeError: If the var does not support contains check.
-        """
-        raise TypeError(
-            f"Var of type {self._var_type} does not support contains check."
-        )
-
     def __get__(self, instance: Any, owner: Any):
         """Get the var.
 
@@ -1023,14 +1018,6 @@ class Var(Generic[VAR_TYPE]):
         """
         return self
 
-    def reverse(self):
-        """Reverse the var.
-
-        Raises:
-            TypeError: If the var does not support reverse.
-        """
-        raise TypeError("Cannot reverse non-list var.")
-
     def __getattr__(self, name: str):
         """Get an attribute of the var.
 
@@ -1047,6 +1034,13 @@ class Var(Generic[VAR_TYPE]):
         if name.startswith("_"):
             return self.__getattribute__(name)
 
+        if name == "contains":
+            raise TypeError(
+                f"Var of type {self._var_type} does not support contains check."
+            )
+        if name == "reverse":
+            raise TypeError("Cannot reverse non-list var.")
+
         if self._var_type is Any:
             raise TypeError(
                 f"You must provide an annotation for the state var `{str(self)}`. Annotation cannot be `{self._var_type}`."
@@ -1075,10 +1069,7 @@ class Var(Generic[VAR_TYPE]):
         try:
             return json.loads(str(self))
         except ValueError:
-            try:
-                return json.loads(self.json())
-            except (ValueError, NotImplementedError):
-                return str(self)
+            return str(self)
 
     @property
     def _var_state(self) -> str:
@@ -1156,17 +1147,12 @@ class Var(Generic[VAR_TYPE]):
             "'in' operator not supported for Var types, use Var.contains() instead."
         )
 
-    def json(self) -> str:
-        """Serialize the var to a JSON string.
-
-        Raises:
-            NotImplementedError: If the method is not implemented.
-        """
-        raise NotImplementedError("Var subclasses must implement the json method.")
-
 
 OUTPUT = TypeVar("OUTPUT", bound=Var)
 
+VAR_SUBCLASS = TypeVar("VAR_SUBCLASS", bound=Var)
+VAR_INSIDE = TypeVar("VAR_INSIDE")
+
 
 class ToOperation:
     """A var operation that converts a var to another type."""
@@ -1822,6 +1808,14 @@ class ComputedVar(Var[RETURN_TYPE]):
             "return", Any
         )
 
+        if hint is Any:
+            console.deprecate(
+                "untyped-computed-var",
+                "ComputedVar should have a return type annotation.",
+                "0.6.5",
+                "0.7.0",
+            )
+
         kwargs.setdefault("_js_expr", fget.__name__)
         kwargs.setdefault("_var_type", hint)
 
@@ -2015,17 +2009,28 @@ class ComputedVar(Var[RETURN_TYPE]):
             )
 
         if not self._cache:
-            return self.fget(instance)
-
-        # handle caching
-        if not hasattr(instance, self._cache_attr) or self.needs_update(instance):
-            # Set cache attr on state instance.
-            setattr(instance, self._cache_attr, self.fget(instance))
-            # Ensure the computed var gets serialized to redis.
-            instance._was_touched = True
-            # Set the last updated timestamp on the state instance.
-            setattr(instance, self._last_updated_attr, datetime.datetime.now())
-        return getattr(instance, self._cache_attr)
+            value = self.fget(instance)
+        else:
+            # handle caching
+            if not hasattr(instance, self._cache_attr) or self.needs_update(instance):
+                # Set cache attr on state instance.
+                setattr(instance, self._cache_attr, self.fget(instance))
+                # Ensure the computed var gets serialized to redis.
+                instance._was_touched = True
+                # Set the last updated timestamp on the state instance.
+                setattr(instance, self._last_updated_attr, datetime.datetime.now())
+            value = getattr(instance, self._cache_attr)
+
+        if not _isinstance(value, self._var_type):
+            console.deprecate(
+                "mismatched-computed-var-return",
+                f"Computed var {type(instance).__name__}.{self._js_expr} returned value of type {type(value)}, "
+                f"expected {self._var_type}. This might cause unexpected behavior.",
+                "0.6.5",
+                "0.7.0",
+            )
+
+        return value
 
     def _deps(
         self,
@@ -2855,6 +2860,8 @@ def dispatch(
 
 V = TypeVar("V")
 
+BASE_TYPE = TypeVar("BASE_TYPE", bound=Base)
+
 
 class Field(Generic[T]):
     """Shadow class for Var to allow for type hinting in the IDE."""
@@ -2891,6 +2898,11 @@ class Field(Generic[T]):
         self: Field[Dict[str, V]], instance: None, owner
     ) -> ObjectVar[Dict[str, V]]: ...
 
+    @overload
+    def __get__(
+        self: Field[BASE_TYPE], instance: None, owner
+    ) -> ObjectVar[BASE_TYPE]: ...
+
     @overload
     def __get__(self, instance: None, owner) -> Var[T]: ...
 

reflex/vars/function.py

@@ -4,17 +4,12 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import Any, Callable, Optional, Tuple, Type, Union
+from typing import Any, Callable, Optional, Sequence, Tuple, Type, Union
 
+from reflex.utils import format
 from reflex.utils.types import GenericType
 
-from .base import (
-    CachedVarOperation,
-    LiteralVar,
-    Var,
-    VarData,
-    cached_property_no_lock,
-)
+from .base import CachedVarOperation, LiteralVar, Var, VarData, cached_property_no_lock
 
 
 class FunctionVar(Var[Callable], python_types=Callable):
@@ -132,6 +127,36 @@ class VarOperationCall(CachedVarOperation, Var):
         )
 
 
+@dataclasses.dataclass(frozen=True)
+class DestructuredArg:
+    """Class for destructured arguments."""
+
+    fields: Tuple[str, ...] = tuple()
+    rest: Optional[str] = None
+
+    def to_javascript(self) -> str:
+        """Convert the destructured argument to JavaScript.
+
+        Returns:
+            The destructured argument in JavaScript.
+        """
+        return format.wrap(
+            ", ".join(self.fields) + (f", ...{self.rest}" if self.rest else ""),
+            "{",
+            "}",
+        )
+
+
+@dataclasses.dataclass(
+    frozen=True,
+)
+class FunctionArgs:
+    """Class for function arguments."""
+
+    args: Tuple[Union[str, DestructuredArg], ...] = tuple()
+    rest: Optional[str] = None
+
+
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
@@ -140,8 +165,9 @@ class VarOperationCall(CachedVarOperation, Var):
 class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
     """Base class for immutable function defined via arguments and return expression."""
 
-    _args_names: Tuple[str, ...] = dataclasses.field(default_factory=tuple)
+    _args: FunctionArgs = dataclasses.field(default_factory=FunctionArgs)
     _return_expr: Union[Var, Any] = dataclasses.field(default=None)
+    _explicit_return: bool = dataclasses.field(default=False)
 
     @cached_property_no_lock
     def _cached_var_name(self) -> str:
@@ -150,13 +176,31 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
         Returns:
             The name of the var.
         """
-        return f"(({', '.join(self._args_names)}) => ({str(LiteralVar.create(self._return_expr))}))"
+        arg_names_str = ", ".join(
+            [
+                arg if isinstance(arg, str) else arg.to_javascript()
+                for arg in self._args.args
+            ]
+        ) + (f", ...{self._args.rest}" if self._args.rest else "")
+
+        return_expr_str = str(LiteralVar.create(self._return_expr))
+
+        # Wrap return expression in curly braces if explicit return syntax is used.
+        return_expr_str_wrapped = (
+            format.wrap(return_expr_str, "{", "}")
+            if self._explicit_return
+            else return_expr_str
+        )
+
+        return f"(({arg_names_str}) => {return_expr_str_wrapped})"
 
     @classmethod
     def create(
         cls,
-        args_names: Tuple[str, ...],
+        args_names: Sequence[Union[str, DestructuredArg]],
         return_expr: Var | Any,
+        rest: str | None = None,
+        explicit_return: bool = False,
         _var_type: GenericType = Callable,
         _var_data: VarData | None = None,
     ) -> ArgsFunctionOperation:
@@ -165,6 +209,8 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
         Args:
             args_names: The names of the arguments.
             return_expr: The return expression of the function.
+            rest: The name of the rest argument.
+            explicit_return: Whether to use explicit return syntax.
             _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
@@ -174,8 +220,9 @@ class ArgsFunctionOperation(CachedVarOperation, FunctionVar):
             _js_expr="",
             _var_type=_var_type,
             _var_data=_var_data,
-            _args_names=args_names,
+            _args=FunctionArgs(args=tuple(args_names), rest=rest),
             _return_expr=return_expr,
+            _explicit_return=explicit_return,
         )
 
 

reflex/vars/number.py

@@ -1116,7 +1116,9 @@ U = TypeVar("U")
 
 
 @var_operation
-def ternary_operation(condition: BooleanVar, if_true: Var[T], if_false: Var[U]):
+def ternary_operation(
+    condition: BooleanVar, if_true: Var[T], if_false: Var[U]
+) -> CustomVarOperationReturn[Union[T, U]]:
     """Create a ternary operation.
 
     Args: