reflex 0.7.13a1__py3-none-any.whl → 0.7.14__py3-none-any.whl

reflex/vars/base.py

@@ -247,9 +247,8 @@ class VarData:
         )
         if positions:
             if len(positions) > 1:
-                raise exceptions.ReflexError(
-                    f"Cannot merge var data with different positions: {positions}"
-                )
+                msg = f"Cannot merge var data with different positions: {positions}"
+                raise exceptions.ReflexError(msg)
             position = positions[0]
         else:
             position = None
@@ -511,14 +510,12 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             TypeError: If _js_expr is not a string.
         """
         if not isinstance(self._js_expr, str):
-            raise TypeError(
-                f"Expected _js_expr to be a string, got value {self._js_expr!r} of type {type(self._js_expr).__name__}"
-            )
+            msg = f"Expected _js_expr to be a string, got value {self._js_expr!r} of type {type(self._js_expr).__name__}"
+            raise TypeError(msg)
 
         if self._var_data is not None and not isinstance(self._var_data, VarData):
-            raise TypeError(
-                f"Expected _var_data to be a VarData, got value {self._var_data!r} of type {type(self._var_data).__name__}"
-            )
+            msg = f"Expected _var_data to be a VarData, got value {self._var_data!r} of type {type(self._var_data).__name__}"
+            raise TypeError(msg)
 
         # Decode any inline Var markup and apply it to the instance
         _var_data, _js_expr = _decode_var_immutable(self._js_expr)
@@ -597,15 +594,16 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             TypeError: If _var_is_local, _var_is_string, or _var_full_name_needs_state_prefix is not None.
         """
         if kwargs.get("_var_is_local", False) is not False:
-            raise TypeError("The _var_is_local argument is not supported for Var.")
+            msg = "The _var_is_local argument is not supported for Var."
+            raise TypeError(msg)
 
         if kwargs.get("_var_is_string", False) is not False:
-            raise TypeError("The _var_is_string argument is not supported for Var.")
+            msg = "The _var_is_string argument is not supported for Var."
+            raise TypeError(msg)
 
         if kwargs.get("_var_full_name_needs_state_prefix", False) is not False:
-            raise TypeError(
-                "The _var_full_name_needs_state_prefix argument is not supported for Var."
-            )
+            msg = "The _var_full_name_needs_state_prefix argument is not supported for Var."
+            raise TypeError(msg)
         value_with_replaced = dataclasses.replace(
             self,
             _var_type=_var_type or self._var_type,
@@ -850,10 +848,9 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
                         new_var_type = var_type
                     else:
                         new_var_type = var_type or current_var_type
-                    to_operation_return = var_subclass.to_var_subclass.create(
+                    return var_subclass.to_var_subclass.create(  # pyright: ignore [reportReturnType]
                         value=self, _var_type=new_var_type
                     )
-                    return to_operation_return  # pyright: ignore [reportReturnType]
 
             # If we can't determine the first argument, we just replace the _var_type.
             if not safe_issubclass(output, Var) or var_type is None:
@@ -940,7 +937,8 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             fixed_type = unionize(*(type(arg) for arg in args))
 
         if not inspect.isclass(fixed_type):
-            raise TypeError(f"Unsupported type {var_type} for guess_type.")
+            msg = f"Unsupported type {var_type} for guess_type."
+            raise TypeError(msg)
 
         if fixed_type is None:
             return self.to(None)
@@ -992,9 +990,8 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
 
                 return pd.DataFrame()
             except ImportError as e:
-                raise ImportError(
-                    "Please install pandas to use dataframes in your app."
-                ) from e
+                msg = "Please install pandas to use dataframes in your app."
+                raise ImportError(msg) from e
         return set() if safe_issubclass(type_, set) else None
 
     def _get_setter_name(self, include_state: bool = True) -> str:
@@ -1012,7 +1009,7 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             return setter
         if not include_state or var_data.state == "":
             return setter
-        return ".".join((var_data.state, setter))
+        return var_data.state + "." + setter
 
     def _get_setter(self) -> Callable[[BaseState, Any], None]:
         """Get the var's setter function.
@@ -1348,9 +1345,8 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
                     self,
                     f"access the item '{key}'",
                 )
-            raise TypeError(
-                f"Var of type {self._var_type} does not support item access."
-            )
+            msg = f"Var of type {self._var_type} does not support item access."
+            raise TypeError(msg)
 
         def __getattr__(self, name: str):
             """Get an attribute of the var.
@@ -1366,14 +1362,15 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
             # noqa: DAR101 self
             """
             if name.startswith("_"):
-                raise VarAttributeError(f"Attribute {name} not found.")
+                msg = f"Attribute {name} not found."
+                raise VarAttributeError(msg)
 
             if name == "contains":
-                raise TypeError(
-                    f"Var of type {self._var_type} does not support contains check."
-                )
+                msg = f"Var of type {self._var_type} does not support contains check."
+                raise TypeError(msg)
             if name == "reverse":
-                raise TypeError("Cannot reverse non-list var.")
+                msg = "Cannot reverse non-list var."
+                raise TypeError(msg)
 
             if self._var_type is Any:
                 raise exceptions.UntypedVarError(
@@ -1381,9 +1378,8 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
                     f"access the attribute '{name}'",
                 )
 
-            raise VarAttributeError(
-                f"The State var {escape(self._js_expr)} of type {escape(str(self._var_type))} has no attribute '{name}' or may have been annotated wrongly.",
-            )
+            msg = f"The State var {escape(self._js_expr)} of type {escape(str(self._var_type))} has no attribute '{name}' or may have been annotated wrongly."
+            raise VarAttributeError(msg)
 
         def __bool__(self) -> bool:
             """Raise exception if using Var in a boolean context.
@@ -1393,10 +1389,11 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
 
             # noqa: DAR101 self
             """
-            raise VarTypeError(
+            msg = (
                 f"Cannot convert Var {str(self)!r} to bool for use with `if`, `and`, `or`, and `not`. "
                 "Instead use `rx.cond` and bitwise operators `&` (and), `|` (or), `~` (invert)."
             )
+            raise VarTypeError(msg)
 
         def __iter__(self) -> Any:
             """Raise exception if using Var in an iterable context.
@@ -1406,9 +1403,8 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
 
             # noqa: DAR101 self
             """
-            raise VarTypeError(
-                f"Cannot iterate over Var {str(self)!r}. Instead use `rx.foreach`."
-            )
+            msg = f"Cannot iterate over Var {str(self)!r}. Instead use `rx.foreach`."
+            raise VarTypeError(msg)
 
         def __contains__(self, _: Any) -> Var:
             """Override the 'in' operator to alert the user that it is not supported.
@@ -1418,9 +1414,10 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
 
             # noqa: DAR101 self
             """
-            raise VarTypeError(
+            msg = (
                 "'in' operator not supported for Var types, use Var.contains() instead."
             )
+            raise VarTypeError(msg)
 
 
 OUTPUT = TypeVar("OUTPUT", bound=Var)
@@ -1522,9 +1519,8 @@ class LiteralVar(Var):
         ]
 
         if not possible_bases:
-            raise TypeError(
-                f"LiteralVar subclass {cls} must have a base class that is a subclass of Var and not LiteralVar."
-            )
+            msg = f"LiteralVar subclass {cls} must have a base class that is a subclass of Var and not LiteralVar."
+            raise TypeError(msg)
 
         var_subclasses = [
             var_subclass
@@ -1533,14 +1529,12 @@ class LiteralVar(Var):
         ]
 
         if not var_subclasses:
-            raise TypeError(
-                f"LiteralVar {cls} must have a base class annotated with `python_types`."
-            )
+            msg = f"LiteralVar {cls} must have a base class annotated with `python_types`."
+            raise TypeError(msg)
 
         if len(var_subclasses) != 1:
-            raise TypeError(
-                f"LiteralVar {cls} must have exactly one base class annotated with `python_types`."
-            )
+            msg = f"LiteralVar {cls} must have exactly one base class annotated with `python_types`."
+            raise TypeError(msg)
 
         var_subclass = var_subclasses[0]
 
@@ -1630,9 +1624,8 @@ class LiteralVar(Var):
         if isinstance(value, range):
             return ArrayVar.range(value.start, value.stop, value.step)
 
-        raise TypeError(
-            f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
-        )
+        msg = f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
+        raise TypeError(msg)
 
     if not TYPE_CHECKING:
         create = _create_literal_var
@@ -1642,9 +1635,8 @@ class LiteralVar(Var):
 
     @property
     def _var_value(self) -> Any:
-        raise NotImplementedError(
-            "LiteralVar subclasses must implement the _var_value property."
-        )
+        msg = "LiteralVar subclasses must implement the _var_value property."
+        raise NotImplementedError(msg)
 
     def json(self) -> str:
         """Serialize the var to a JSON string.
@@ -1652,9 +1644,8 @@ class LiteralVar(Var):
         Raises:
             NotImplementedError: If the method is not implemented.
         """
-        raise NotImplementedError(
-            "LiteralVar subclasses must implement the json method."
-        )
+        msg = "LiteralVar subclasses must implement the json method."
+        raise NotImplementedError(msg)
 
 
 @serializers.serializer
@@ -1881,10 +1872,11 @@ class cached_property:  # noqa: N801
             owner.__del__ = delete_property
 
         elif name != self._attrname:
-            raise TypeError(
+            msg = (
                 "Cannot assign the same cached_property to two different names "
                 f"({self._attrname!r} and {name!r})."
             )
+            raise TypeError(msg)
 
     def __get__(self, instance: Any, owner: type | None = None):
         """Get the cached property.
@@ -1900,9 +1892,8 @@ class cached_property:  # noqa: N801
             TypeError: If the class does not have __set_name__.
         """
         if self._attrname is None:
-            raise TypeError(
-                "Cannot use cached_property on a class without __set_name__."
-            )
+            msg = "Cannot use cached_property on a class without __set_name__."
+            raise TypeError(msg)
         cached_field_name = "_reflex_cache_" + self._attrname
         try:
             unique_id = object.__getattribute__(instance, cached_field_name)
@@ -2164,7 +2155,8 @@ class ComputedVar(Var[RETURN_TYPE]):
         )
 
         if kwargs:
-            raise TypeError(f"Unexpected keyword arguments: {tuple(kwargs)}")
+            msg = f"Unexpected keyword arguments: {tuple(kwargs)}"
+            raise TypeError(msg)
 
         if backend is None:
             backend = fget.__name__.startswith("_")
@@ -2239,9 +2231,8 @@ class ComputedVar(Var[RETURN_TYPE]):
         elif isinstance(dep, str) and dep != "":
             deps.setdefault(None, set()).add(dep)
         else:
-            raise TypeError(
-                "ComputedVar dependencies must be Var instances or var names (non-empty strings)."
-            )
+            msg = "ComputedVar dependencies must be Var instances or var names (non-empty strings)."
+            raise TypeError(msg)
         return deps
 
     @override
@@ -2282,7 +2273,8 @@ class ComputedVar(Var[RETURN_TYPE]):
 
         if kwargs:
             unexpected_kwargs = ", ".join(kwargs.keys())
-            raise TypeError(f"Unexpected keyword arguments: {unexpected_kwargs}")
+            msg = f"Unexpected keyword arguments: {unexpected_kwargs}"
+            raise TypeError(msg)
 
         return type(self)(**field_values)
 
@@ -2529,10 +2521,11 @@ class ComputedVar(Var[RETURN_TYPE]):
                         (objclass.get_full_name(), self._js_expr)
                     )
                     return
-        raise VarDependencyError(
+        msg = (
             "ComputedVar dependencies must be Var instances with a state and "
             f"field name, got {dep!r}."
         )
+        raise VarDependencyError(msg)
 
     def _determine_var_type(self) -> type:
         """Get the type of the var.
@@ -2567,8 +2560,6 @@ class ComputedVar(Var[RETURN_TYPE]):
 class DynamicRouteVar(ComputedVar[str | list[str]]):
     """A ComputedVar that represents a dynamic route."""
 
-    pass
-
 
 async def _default_async_computed_var(_self: BaseState) -> Any:
     return None
@@ -2683,23 +2674,21 @@ class AsyncComputedVar(ComputedVar[RETURN_TYPE]):
                 return value
 
             return _awaitable_result()
-        else:
-            # handle caching
-            async def _awaitable_result(instance: BaseState = instance) -> RETURN_TYPE:
-                if not hasattr(instance, self._cache_attr) or self.needs_update(
-                    instance
-                ):
-                    # Set cache attr on state instance.
-                    setattr(instance, self._cache_attr, await 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)
-                self._check_deprecated_return_type(instance, value)
-                return value
 
-            return _awaitable_result()
+        # handle caching
+        async def _awaitable_result(instance: BaseState = instance) -> RETURN_TYPE:
+            if not hasattr(instance, self._cache_attr) or self.needs_update(instance):
+                # Set cache attr on state instance.
+                setattr(instance, self._cache_attr, await 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)
+            self._check_deprecated_return_type(instance, value)
+            return value
+
+        return _awaitable_result()
 
     @property
     def fget(self) -> Callable[[BaseState], Coroutine[None, None, RETURN_TYPE]]:
@@ -2806,10 +2795,12 @@ def computed_var(
         ComputedVarSignatureError: If the getter function has more than one argument.
     """
     if cache is False and interval is not None:
-        raise ValueError("Cannot set update interval without caching.")
+        msg = "Cannot set update interval without caching."
+        raise ValueError(msg)
 
     if cache is False and (deps is not None or auto_deps is False):
-        raise VarDependencyError("Cannot track dependencies without caching.")
+        msg = "Cannot track dependencies without caching."
+        raise VarDependencyError(msg)
 
     if fget is not None:
         sign = inspect.signature(fget)
@@ -3031,7 +3022,8 @@ def get_to_operation(var_subclass: type[Var]) -> type[ToOperation]:
         if saved_var_subclass.var_subclass is var_subclass
     ]
     if not possible_classes:
-        raise ValueError(f"Could not find ToOperation for {var_subclass}.")
+        msg = f"Could not find ToOperation for {var_subclass}."
+        raise ValueError(msg)
     return possible_classes[0]
 
 
@@ -3172,21 +3164,20 @@ def transform(fn: Callable[[Var], Var]) -> Callable[[Var], Var]:
     origin = get_origin(return_type)
 
     if origin is not Var:
-        raise TypeError(
-            f"Expected return type of {fn.__name__} to be a Var, got {origin}."
-        )
+        msg = f"Expected return type of {fn.__name__} to be a Var, got {origin}."
+        raise TypeError(msg)
 
     generic_args = get_args(return_type)
 
     if not generic_args:
-        raise TypeError(
-            f"Expected Var return type of {fn.__name__} to have a generic type."
-        )
+        msg = f"Expected Var return type of {fn.__name__} to have a generic type."
+        raise TypeError(msg)
 
     generic_type = get_origin(generic_args[0]) or generic_args[0]
 
     if generic_type in dispatchers:
-        raise ValueError(f"Function for {generic_type} already registered.")
+        msg = f"Function for {generic_type} already registered."
+        raise ValueError(msg)
 
     dispatchers[generic_type] = fn
 
@@ -3215,17 +3206,15 @@ def generic_type_to_actual_type_map(
     if generic_origin is not actual_origin:
         if isinstance(generic_origin, TypeVar):
             return {generic_origin: actual_origin}
-        raise TypeError(
-            f"Type mismatch: expected {generic_origin}, got {actual_origin}."
-        )
+        msg = f"Type mismatch: expected {generic_origin}, got {actual_origin}."
+        raise TypeError(msg)
 
     generic_args = get_args(generic_type)
     actual_args = get_args(actual_type)
 
     if len(generic_args) != len(actual_args):
-        raise TypeError(
-            f"Number of generic arguments mismatch: expected {len(generic_args)}, got {len(actual_args)}."
-        )
+        msg = f"Number of generic arguments mismatch: expected {len(generic_args)}, got {len(actual_args)}."
+        raise TypeError(msg)
 
     # call recursively for nested generic types and merge the results
     return {
@@ -3326,28 +3315,26 @@ def dispatch(
         fn_return_origin = get_origin(fn_return) or fn_return
 
         if fn_return_origin is not Var:
-            raise TypeError(
-                f"Expected return type of {fn.__name__} to be a Var, got {fn_return}."
-            )
+            msg = f"Expected return type of {fn.__name__} to be a Var, got {fn_return}."
+            raise TypeError(msg)
 
         fn_return_generic_args = get_args(fn_return)
 
         if not fn_return_generic_args:
-            raise TypeError(f"Expected generic type of {fn_return} to be a type.")
+            msg = f"Expected generic type of {fn_return} to be a type."
+            raise TypeError(msg)
 
         arg_origin = get_origin(fn_first_arg_type) or fn_first_arg_type
 
         if arg_origin is not Var:
-            raise TypeError(
-                f"Expected first argument of {fn.__name__} to be a Var, got {fn_first_arg_type}."
-            )
+            msg = f"Expected first argument of {fn.__name__} to be a Var, got {fn_first_arg_type}."
+            raise TypeError(msg)
 
         arg_generic_args = get_args(fn_first_arg_type)
 
         if not arg_generic_args:
-            raise TypeError(
-                f"Expected generic type of {fn_first_arg_type} to be a type."
-            )
+            msg = f"Expected generic type of {fn_first_arg_type} to be a type."
+            raise TypeError(msg)
 
         arg_type = arg_generic_args[0]
         fn_return_type = fn_return_generic_args[0]

reflex/vars/datetime.py

@@ -29,7 +29,8 @@ def raise_var_type_error():
     Raises:
         VarTypeError: Cannot compare a datetime object with a non-datetime object.
     """
-    raise VarTypeError("Cannot compare a datetime object with a non-datetime object.")
+    msg = "Cannot compare a datetime object with a non-datetime object."
+    raise VarTypeError(msg)
 
 
 class DateTimeVar(Var[DATETIME_T], python_types=(datetime, date)):

reflex/vars/dep_tracking.py

@@ -73,7 +73,7 @@ class DependencyTracker:
             self.func = cast(FunctionType, self.func.func)  # pyright: ignore[reportAttributeAccessIssue]
         with contextlib.suppress(AttributeError):
             # unbox EventHandler
-            self.func = cast(FunctionType, self.func.fn)  # pyright: ignore[reportAttributeAccessIssue]
+            self.func = cast(FunctionType, self.func.fn)  # pyright: ignore[reportAttributeAccessIssue,reportFunctionMemberAccess]
 
         if isinstance(self.func, FunctionType):
             with contextlib.suppress(AttributeError, IndexError):
@@ -106,9 +106,8 @@ class DependencyTracker:
         from .base import ComputedVar
 
         if instruction.argval in self.INVALID_NAMES:
-            raise VarValueError(
-                f"Cached var {self!s} cannot access arbitrary state via `{instruction.argval}`."
-            )
+            msg = f"Cached var {self!s} cannot access arbitrary state via `{instruction.argval}`."
+            raise VarValueError(msg)
         if instruction.argval == "get_state":
             # Special case: arbitrary state access requested.
             self.scan_status = ScanStatus.GETTING_STATE
@@ -193,37 +192,32 @@ class DependencyTracker:
         from reflex.state import BaseState
 
         if instruction.opname == "LOAD_FAST":
-            raise VarValueError(
-                f"Dependency detection cannot identify get_state class from local var {instruction.argval}."
-            )
+            msg = f"Dependency detection cannot identify get_state class from local var {instruction.argval}."
+            raise VarValueError(msg)
         if isinstance(self.func, CodeType):
-            raise VarValueError(
-                "Dependency detection cannot identify get_state class from a code object."
-            )
+            msg = "Dependency detection cannot identify get_state class from a code object."
+            raise VarValueError(msg)
         if instruction.opname == "LOAD_GLOBAL":
             # Special case: referencing state class from global scope.
             try:
                 self._getting_state_class = self._get_globals()[instruction.argval]
             except (ValueError, KeyError) as ve:
-                raise VarValueError(
-                    f"Cached var {self!s} cannot access arbitrary state `{instruction.argval}`, not found in globals."
-                ) from ve
+                msg = f"Cached var {self!s} cannot access arbitrary state `{instruction.argval}`, not found in globals."
+                raise VarValueError(msg) from ve
         elif instruction.opname == "LOAD_DEREF":
             # Special case: referencing state class from closure.
             try:
                 self._getting_state_class = self._get_closure()[instruction.argval]
             except (ValueError, KeyError) as ve:
-                raise VarValueError(
-                    f"Cached var {self!s} cannot access arbitrary state `{instruction.argval}`, is it defined yet?"
-                ) from ve
+                msg = f"Cached var {self!s} cannot access arbitrary state `{instruction.argval}`, is it defined yet?"
+                raise VarValueError(msg) from ve
         elif instruction.opname == "STORE_FAST":
             # Storing the result of get_state in a local variable.
             if not isinstance(self._getting_state_class, type) or not issubclass(
                 self._getting_state_class, BaseState
             ):
-                raise VarValueError(
-                    f"Cached var {self!s} cannot determine dependencies in fetched state `{instruction.argval}`."
-                )
+                msg = f"Cached var {self!s} cannot determine dependencies in fetched state `{instruction.argval}`."
+                raise VarValueError(msg)
             self.tracked_locals[instruction.argval] = self._getting_state_class
             self.scan_status = ScanStatus.SCANNING
             self._getting_state_class = None
@@ -242,9 +236,8 @@ class DependencyTracker:
         positions0 = self._getting_var_instructions[0].positions
         positions1 = self._getting_var_instructions[-1].positions
         if module is None or positions0 is None or positions1 is None:
-            raise VarValueError(
-                f"Cannot determine the source code for the var in {self.func!r}."
-            )
+            msg = f"Cannot determine the source code for the var in {self.func!r}."
+            raise VarValueError(msg)
         start_line = positions0.lineno
         start_column = positions0.col_offset
         end_line = positions1.end_lineno
@@ -255,9 +248,8 @@ class DependencyTracker:
             or end_line is None
             or end_column is None
         ):
-            raise VarValueError(
-                f"Cannot determine the source code for the var in {self.func!r}."
-            )
+            msg = f"Cannot determine the source code for the var in {self.func!r}."
+            raise VarValueError(msg)
         source = inspect.getsource(module).splitlines(True)[start_line - 1 : end_line]
         # Create a python source string snippet.
         if len(source) > 1:
@@ -292,9 +284,8 @@ class DependencyTracker:
                 the_var = self._eval_var()
                 the_var_data = the_var._get_all_var_data()
                 if the_var_data is None:
-                    raise VarValueError(
-                        f"Cannot determine the source code for the var in {self.func!r}."
-                    )
+                    msg = f"Cannot determine the source code for the var in {self.func!r}."
+                    raise VarValueError(msg)
                 self.dependencies.setdefault(the_var_data.state, set()).add(
                     the_var_data.field_name
                 )

reflex/vars/number.py

@@ -53,9 +53,8 @@ def raise_unsupported_operand_types(
     Raises:
         VarTypeError: The operand types are unsupported.
     """
-    raise VarTypeError(
-        f"Unsupported Operand type(s) for {operator}: {', '.join(t.__name__ for t in operands_types)}"
-    )
+    msg = f"Unsupported Operand type(s) for {operator}: {', '.join(t.__name__ for t in operands_types)}"
+    raise VarTypeError(msg)
 
 
 class NumberVar(Var[NUMBER_T], python_types=(int, float, decimal.Decimal)):
@@ -486,10 +485,11 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float, decimal.Decimal)):
             )
 
         if format_spec:
-            raise VarValueError(
+            msg = (
                 f"Unknown format code '{format_spec}' for object of type 'NumberVar'. It is only supported to use ',', '_', and '.f' for float numbers."
                 "If possible, use computed variables instead: https://reflex.dev/docs/vars/computed-vars/"
             )
+            raise VarValueError(msg)
 
         return super().__format__(format_spec)
 
@@ -961,9 +961,8 @@ class LiteralNumberVar(LiteralVar, NumberVar[NUMBER_T]):
         if isinstance(self._var_value, decimal.Decimal):
             return json.dumps(float(self._var_value))
         if math.isinf(self._var_value) or math.isnan(self._var_value):
-            raise PrimitiveUnserializableToJSONError(
-                f"No valid JSON representation for {self}"
-            )
+            msg = f"No valid JSON representation for {self}"
+            raise PrimitiveUnserializableToJSONError(msg)
         return json.dumps(self._var_value)
 
     def __hash__(self) -> int:

reflex/vars/object.py

@@ -333,13 +333,13 @@ class ObjectVar(Var[OBJECT_TYPE], python_types=Mapping):
         ):
             attribute_type = get_attribute_access_type(var_type, name)
             if attribute_type is None:
-                raise VarAttributeError(
+                msg = (
                     f"The State var `{self!s}` of type {escape(str(self._var_type))} has no attribute '{name}' or may have been annotated "
                     f"wrongly."
                 )
+                raise VarAttributeError(msg)
             return ObjectItemOperation.create(self, name, attribute_type).guess_type()
-        else:
-            return ObjectItemOperation.create(self, name).guess_type()
+        return ObjectItemOperation.create(self, name).guess_type()
 
     def contains(self, key: Var | Any) -> BooleanVar:
         """Check if the object contains a key.
@@ -413,9 +413,8 @@ class LiteralObjectVar(CachedVarOperation, ObjectVar[OBJECT_TYPE], LiteralVar):
             key = LiteralVar.create(key)
             value = LiteralVar.create(value)
             if not isinstance(key, LiteralVar) or not isinstance(value, LiteralVar):
-                raise TypeError(
-                    "The keys and values of the object must be literal vars to get the JSON representation."
-                )
+                msg = "The keys and values of the object must be literal vars to get the JSON representation."
+                raise TypeError(msg)
             keys_and_values.append(f"{key.json()}:{value.json()}")
         return "{" + ", ".join(keys_and_values) + "}"