optimize various var functions

Author: adhami3310

reflex/utils/types.py

@@ -291,6 +291,7 @@ def is_literal(cls: GenericType) -> bool:
     return getattr(cls, "__origin__", None) is Literal
 
 
+@lru_cache
 def has_args(cls: type) -> bool:
     """Check if the class has generic parameters.
 

reflex/vars/base.py

@@ -1527,6 +1527,82 @@ def _create_literal_var(
     def __post_init__(self):
         """Post-initialize the var."""
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Any,
+    ) -> VarData | None:
+        return cls.create(value)._get_all_var_data()
+
+    @classmethod
+    def _get_all_var_data_without_creating_var_dispatch(
+        cls,
+        value: Any,
+    ) -> VarData | None:
+        """Get all the var data without creating a var.
+
+        Args:
+            value: The value to get the var data from.
+
+        Returns:
+            The var data or None.
+
+        Raises:
+            TypeError: If the value is not a supported type for LiteralVar.
+        """
+        from .object import LiteralObjectVar
+        from .sequence import LiteralStringVar
+
+        if isinstance(value, Var):
+            return value._get_all_var_data()
+
+        for literal_subclass, var_subclass in _var_literal_subclasses[::-1]:
+            if isinstance(value, var_subclass.python_types):
+                return literal_subclass._get_all_var_data_without_creating_var(value)
+
+        if (
+            (as_var_method := getattr(value, "_as_var", None)) is not None
+            and callable(as_var_method)
+            and isinstance((resulting_var := as_var_method()), Var)
+        ):
+            return resulting_var._get_all_var_data()
+
+        from reflex.event import EventHandler
+        from reflex.utils.format import get_event_handler_parts
+
+        if isinstance(value, EventHandler):
+            return Var(
+                _js_expr=".".join(filter(None, get_event_handler_parts(value)))
+            )._get_all_var_data()
+
+        serialized_value = serializers.serialize(value)
+        if serialized_value is not None:
+            if isinstance(serialized_value, Mapping):
+                return LiteralObjectVar._get_all_var_data_without_creating_var(
+                    serialized_value
+                )
+            if isinstance(serialized_value, str):
+                return LiteralStringVar._get_all_var_data_without_creating_var(
+                    serialized_value
+                )
+            return LiteralVar._get_all_var_data_without_creating_var_dispatch(
+                serialized_value
+            )
+
+        if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            return LiteralObjectVar._get_all_var_data_without_creating_var(
+                {
+                    k: (None if callable(v) else v)
+                    for k, v in dataclasses.asdict(value).items()
+                }
+            )
+
+        if isinstance(value, range):
+            return None
+
+        msg = f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
+        raise TypeError(msg)
+
     @property
     def _var_value(self) -> Any:
         msg = "LiteralVar subclasses must implement the _var_value property."
@@ -1688,30 +1764,30 @@ def figure_out_type(value: Any) -> types.GenericType:
     Returns:
         The type of the value.
     """
-    if isinstance(value, Var):
-        return value._var_type
-    type_ = type(value)
-    if has_args(type_):
-        return type_
-    if isinstance(value, list):
-        if not value:
-            return Sequence[NoReturn]
-        return Sequence[unionize(*(figure_out_type(v) for v in value))]
-    if isinstance(value, set):
-        return set[unionize(*(figure_out_type(v) for v in value))]
-    if isinstance(value, tuple):
-        if not value:
-            return tuple[NoReturn, ...]
-        if len(value) <= 5:
-            return tuple[tuple(figure_out_type(v) for v in value)]
-        return tuple[unionize(*(figure_out_type(v) for v in value)), ...]
-    if isinstance(value, Mapping):
-        if not value:
-            return Mapping[NoReturn, NoReturn]
-        return Mapping[
-            unionize(*(figure_out_type(k) for k in value)),
-            unionize(*(figure_out_type(v) for v in value.values())),
-        ]
+    if isinstance(value, (list, set, tuple, Mapping, Var)):
+        if isinstance(value, Var):
+            return value._var_type
+        if has_args(value_type := type(value)):
+            return value_type
+        if isinstance(value, list):
+            if not value:
+                return Sequence[NoReturn]
+            return Sequence[unionize(*{figure_out_type(v) for v in value})]
+        if isinstance(value, set):
+            return set[unionize(*{figure_out_type(v) for v in value})]
+        if isinstance(value, tuple):
+            if not value:
+                return tuple[NoReturn, ...]
+            if len(value) <= 5:
+                return tuple[tuple(figure_out_type(v) for v in value)]
+            return tuple[unionize(*{figure_out_type(v) for v in value}), ...]
+        if isinstance(value, Mapping):
+            if not value:
+                return Mapping[NoReturn, NoReturn]
+            return Mapping[
+                unionize(*{figure_out_type(k) for k in value}),
+                unionize(*{figure_out_type(v) for v in value.values()}),
+            ]
     return type(value)
 
 
@@ -2883,6 +2959,10 @@ def json(self) -> str:
         """
         return "null"
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: None) -> VarData | None:
+        return None
+
     @classmethod
     def create(
         cls,

reflex/vars/color.py

@@ -29,6 +29,23 @@ class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
 
     _var_value: Color = dataclasses.field(default_factory=lambda: Color(color="black"))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Color,
+    ) -> VarData | None:
+        return VarData.merge(
+            LiteralStringVar._get_all_var_data_without_creating_var(value.color)
+            if isinstance(value.color, str)
+            else value.color._get_all_var_data(),
+            value.alpha._get_all_var_data()
+            if not isinstance(value.alpha, bool)
+            else None,
+            value.shade._get_all_var_data()
+            if not isinstance(value.shade, int)
+            else None,
+        )
+
     @classmethod
     def create(
         cls,
@@ -111,14 +128,17 @@ def _cached_get_all_var_data(self) -> VarData | None:
             The var data.
         """
         return VarData.merge(
-            *[
-                LiteralVar.create(var)._get_all_var_data()
-                for var in (
-                    self._var_value.color,
-                    self._var_value.alpha,
-                    self._var_value.shade,
-                )
-            ],
+            LiteralStringVar._get_all_var_data_without_creating_var(
+                self._var_value.color
+            )
+            if isinstance(self._var_value.color, str)
+            else self._var_value.color._get_all_var_data(),
+            self._var_value.alpha._get_all_var_data()
+            if not isinstance(self._var_value.alpha, bool)
+            else None,
+            self._var_value.shade._get_all_var_data()
+            if not isinstance(self._var_value.shade, int)
+            else None,
             self._var_data,
         )
 

reflex/vars/datetime.py

@@ -174,10 +174,14 @@ def date_compare_operation(
 class LiteralDatetimeVar(LiteralVar, DateTimeVar):
     """Base class for immutable datetime and date vars."""
 
-    _var_value: datetime | date = dataclasses.field(default=datetime.now())
+    _var_value: date = dataclasses.field(default=datetime.now())
 
     @classmethod
-    def create(cls, value: datetime | date, _var_data: VarData | None = None):
+    def _get_all_var_data_without_creating_var(cls, value: date) -> VarData | None:
+        return None
+
+    @classmethod
+    def create(cls, value: date, _var_data: VarData | None = None):
         """Create a new instance of the class.
 
         Args:

reflex/vars/number.py

@@ -973,6 +973,20 @@ def __hash__(self) -> int:
         """
         return hash((type(self).__name__, self._var_value))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls, value: float | int | decimal.Decimal
+    ) -> VarData | None:
+        """Get all the var data without creating the var.
+
+        Args:
+            value: The value of the var.
+
+        Returns:
+            The var data.
+        """
+        return None
+
     @classmethod
     def create(
         cls, value: float | int | decimal.Decimal, _var_data: VarData | None = None
@@ -1027,6 +1041,18 @@ def __hash__(self) -> int:
         """
         return hash((type(self).__name__, self._var_value))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: bool) -> VarData | None:
+        """Get all the var data without creating the var.
+
+        Args:
+            value: The value of the var.
+
+        Returns:
+            The var data.
+        """
+        return None
+
     @classmethod
     def create(cls, value: bool, _var_data: VarData | None = None):
         """Create the boolean var.

reflex/vars/object.py

@@ -40,7 +40,7 @@
     var_operation_return,
 )
 from .number import BooleanVar, NumberVar, raise_unsupported_operand_types
-from .sequence import ArrayVar, StringVar
+from .sequence import ArrayVar, LiteralArrayVar, StringVar
 
 OBJECT_TYPE = TypeVar("OBJECT_TYPE", covariant=True)
 
@@ -437,6 +437,24 @@ def __hash__(self) -> int:
         """
         return hash((type(self).__name__, self._js_expr))
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(
+        cls,
+        value: Mapping,
+    ) -> VarData | None:
+        """Get all the var data without creating a var.
+
+        Args:
+            value: The value to get the var data from.
+
+        Returns:
+            The var data.
+        """
+        return VarData.merge(
+            LiteralArrayVar._get_all_var_data_without_creating_var(value),
+            LiteralArrayVar._get_all_var_data_without_creating_var(value.values()),
+        )
+
     @cached_property_no_lock
     def _cached_get_all_var_data(self) -> VarData | None:
         """Get all the var data.
@@ -445,11 +463,10 @@ def _cached_get_all_var_data(self) -> VarData | None:
             The var data.
         """
         return VarData.merge(
-            *[LiteralVar.create(var)._get_all_var_data() for var in self._var_value],
-            *[
-                LiteralVar.create(var)._get_all_var_data()
-                for var in self._var_value.values()
-            ],
+            LiteralArrayVar._get_all_var_data_without_creating_var(self._var_value),
+            LiteralArrayVar._get_all_var_data_without_creating_var(
+                self._var_value.values()
+            ),
             self._var_data,
         )
 

reflex/vars/sequence.py

@@ -495,6 +495,23 @@ def _cached_var_name(self) -> str:
             + "]"
         )
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: Iterable) -> VarData | None:
+        """Get all the VarData associated with the Var without creating a Var.
+
+        Args:
+            value: The value to get the VarData for.
+
+        Returns:
+            The VarData associated with the Var.
+        """
+        return VarData.merge(
+            *[
+                LiteralVar._get_all_var_data_without_creating_var_dispatch(element)
+                for element in value
+            ]
+        )
+
     @cached_property_no_lock
     def _cached_get_all_var_data(self) -> VarData | None:
         """Get all the VarData associated with the Var.
@@ -504,7 +521,7 @@ def _cached_get_all_var_data(self) -> VarData | None:
         """
         return VarData.merge(
             *[
-                LiteralVar.create(element)._get_all_var_data()
+                LiteralVar._get_all_var_data_without_creating_var_dispatch(element)
                 for element in self._var_value
             ],
             self._var_data,
@@ -1147,6 +1164,20 @@ class LiteralStringVar(LiteralVar, StringVar[str]):
 
     _var_value: str = dataclasses.field(default="")
 
+    @classmethod
+    def _get_all_var_data_without_creating_var(cls, value: str) -> VarData | None:
+        """Get all the VarData associated with the Var without creating a Var.
+
+        Args:
+            value: The value to get the VarData for.
+
+        Returns:
+            The VarData associated with the Var.
+        """
+        if REFLEX_VAR_OPENING_TAG not in value:
+            return None
+        return cls.create(value)._get_all_var_data()
+
     @classmethod
     def create(
         cls,