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

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) + "}"
 

reflex/vars/sequence.py

@@ -445,9 +445,8 @@ class ArrayVar(Var[ARRAY_VAR_TYPE], python_types=(Sequence, set)):
         # get the number of arguments of the function
         num_args = len(inspect.signature(fn).parameters)
         if num_args > 1:
-            raise VarTypeError(
-                "The function passed to foreach should take at most one argument."
-            )
+            msg = "The function passed to foreach should take at most one argument."
+            raise VarTypeError(msg)
 
         if num_args == 0:
             return_value = fn()
@@ -535,9 +534,8 @@ class LiteralArrayVar(CachedVarOperation, LiteralVar, ArrayVar[ARRAY_VAR_TYPE]):
         for element in self._var_value:
             element_var = LiteralVar.create(element)
             if not isinstance(element_var, LiteralVar):
-                raise TypeError(
-                    f"Array elements must be of type LiteralVar, not {type(element_var)}"
-                )
+                msg = f"Array elements must be of type LiteralVar, not {type(element_var)}"
+                raise TypeError(msg)
             elements.append(element_var.json())
 
         return "[" + ", ".join(elements) + "]"
@@ -1203,8 +1201,7 @@ class LiteralStringVar(LiteralVar, StringVar[str]):
                 only_string = filtered_strings_and_vals[0]
                 if isinstance(only_string, str):
                     return LiteralVar.create(only_string).to(StringVar, _var_type)
-                else:
-                    return only_string.to(StringVar, only_string._var_type)
+                return only_string.to(StringVar, only_string._var_type)
 
             if len(
                 literal_strings := [
@@ -1400,7 +1397,8 @@ class ArraySliceOperation(CachedVarOperation, ArrayVar):
                 actual_end = start + 1 if start is not None else self._array.length()
                 return str(self._array[actual_start:actual_end].reverse()[::-step])
             if step == 0:
-                raise ValueError("slice step cannot be zero")
+                msg = "slice step cannot be zero"
+                raise ValueError(msg)
             return f"{self._array!s}.slice({normalized_start!s}, {normalized_end!s}).filter((_, i) => i % {step!s} === 0)"
 
         actual_start_reverse = end + 1 if end is not None else 0
@@ -1866,13 +1864,15 @@ class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
             (self._var_value.color, self._var_value.alpha, self._var_value.shade),
         )
         if color is None or alpha is None or shade is None:
-            raise TypeError("Cannot serialize color that contains non-literal vars.")
+            msg = "Cannot serialize color that contains non-literal vars."
+            raise TypeError(msg)
         if (
             not isinstance(color, str)
             or not isinstance(alpha, bool)
             or not isinstance(shade, int)
         ):
-            raise TypeError("Color is not a valid color.")
+            msg = "Color is not a valid color."
+            raise TypeError(msg)
         return f"var(--{color}-{'a' if alpha else ''}{shade})"
 
 

{reflex-0.7.13a2.dist-info → reflex-0.7.14a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.7.13a2
+Version: 0.7.14a1
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex