reflex 0.7.7a2__py3-none-any.whl → 0.7.8__py3-none-any.whl

reflex/utils/types.py

@@ -4,27 +4,20 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import sys
 import types
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from functools import cached_property, lru_cache, wraps
 from types import GenericAlias
-from typing import (
+from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
-    Callable,
     ClassVar,
     Dict,
     ForwardRef,
-    FrozenSet,
-    Iterable,
     List,
     Literal,
-    Mapping,
     NoReturn,
-    Optional,
-    Sequence,
     Tuple,
-    Type,
     Union,
     _GenericAlias,  # pyright: ignore [reportAttributeAccessIssue]
     _SpecialGenericAlias,  # pyright: ignore [reportAttributeAccessIssue]
@@ -55,11 +48,11 @@ GenericAliasTypes = (_GenericAlias, GenericAlias, _SpecialGenericAlias)
 UnionTypes = (Union, types.UnionType)
 
 # Union of generic types.
-GenericType = Type | _GenericAlias
+GenericType = type | _GenericAlias
 
 # Valid state var types.
 JSONType = {str, int, float, bool}
-PrimitiveType = Union[int, float, bool, str, list, dict, set, tuple]
+PrimitiveType = int | float | bool | str | list | dict | set | tuple
 PrimitiveTypes = (int, float, bool, str, list, dict, set, tuple)
 StateVar = PrimitiveType | Base | None
 StateIterVar = list | set | tuple
@@ -82,9 +75,9 @@ else:
 
 
 PrimitiveToAnnotation = {
-    list: List,
-    tuple: Tuple,
-    dict: Dict,
+    list: List,  # noqa: UP006
+    tuple: Tuple,  # noqa: UP006
+    dict: Dict,  # noqa: UP006
 }
 
 RESERVED_BACKEND_VAR_NAMES = {
@@ -117,7 +110,7 @@ class Unset:
         return False
 
 
-@lru_cache()
+@lru_cache
 def get_origin(tp: Any):
     """Get the origin of a class.
 
@@ -130,7 +123,7 @@ def get_origin(tp: Any):
     return get_origin_og(tp)
 
 
-@lru_cache()
+@lru_cache
 def is_generic_alias(cls: GenericType) -> bool:
     """Check whether the class is a generic alias.
 
@@ -143,8 +136,8 @@ def is_generic_alias(cls: GenericType) -> bool:
     return isinstance(cls, GenericAliasTypes)
 
 
-@lru_cache()
-def get_type_hints(obj: Any) -> Dict[str, Any]:
+@lru_cache
+def get_type_hints(obj: Any) -> dict[str, Any]:
     """Get the type hints of a class.
 
     Args:
@@ -156,7 +149,7 @@ def get_type_hints(obj: Any) -> Dict[str, Any]:
     return get_type_hints_og(obj)
 
 
-def _unionize(args: list[GenericType]) -> Type:
+def _unionize(args: list[GenericType]) -> type:
     if not args:
         return Any  # pyright: ignore [reportReturnType]
     if len(args) == 1:
@@ -165,10 +158,10 @@ def _unionize(args: list[GenericType]) -> Type:
     # In Python versions >= 3.11, we can simply do `return Union[*args]`
     midpoint = len(args) // 2
     first_half, second_half = args[:midpoint], args[midpoint:]
-    return Union[unionize(*first_half), unionize(*second_half)]  # pyright: ignore [reportReturnType]
+    return Union[unionize(*first_half), unionize(*second_half)]  # pyright: ignore [reportReturnType]  # noqa: UP007
 
 
-def unionize(*args: GenericType) -> Type:
+def unionize(*args: GenericType) -> type:
     """Unionize the types.
 
     Args:
@@ -192,7 +185,7 @@ def is_none(cls: GenericType) -> bool:
     return cls is type(None) or cls is None
 
 
-@lru_cache()
+@lru_cache
 def is_union(cls: GenericType) -> bool:
     """Check if a class is a Union.
 
@@ -205,7 +198,7 @@ def is_union(cls: GenericType) -> bool:
     return get_origin(cls) in UnionTypes
 
 
-@lru_cache()
+@lru_cache
 def is_literal(cls: GenericType) -> bool:
     """Check if a class is a Literal.
 
@@ -218,7 +211,7 @@ def is_literal(cls: GenericType) -> bool:
     return get_origin(cls) is Literal
 
 
-def has_args(cls: Type) -> bool:
+def has_args(cls: type) -> bool:
     """Check if the class has generic parameters.
 
     Args:
@@ -273,7 +266,7 @@ def true_type_for_pydantic_field(f: ModelField):
             and f.annotation.__forward_arg__.startswith("Optional")
         )
     ) and not is_optional(type_):
-        return Optional[type_]
+        return type_ | None
 
     return type_
 
@@ -414,10 +407,7 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
         )
     elif isinstance(cls, type):
         # Bare class
-        if sys.version_info >= (3, 10):
-            exceptions = NameError
-        else:
-            exceptions = (NameError, TypeError)
+        exceptions = NameError
         try:
             hints = get_type_hints(cls)
             if name in hints:
@@ -428,8 +418,8 @@ def get_attribute_access_type(cls: GenericType, name: str) -> GenericType | None
     return None  # Attribute is not accessible.
 
 
-@lru_cache()
-def get_base_class(cls: GenericType) -> Type:
+@lru_cache
+def get_base_class(cls: GenericType) -> type:
     """Get the base class of a class.
 
     Args:
@@ -548,7 +538,7 @@ def does_obj_satisfy_typed_dict(obj: Any, cls: GenericType) -> bool:
         return False
 
     key_names_to_values = get_type_hints(cls)
-    required_keys: FrozenSet[str] = getattr(cls, "__required_keys__", frozenset())
+    required_keys: frozenset[str] = getattr(cls, "__required_keys__", frozenset())
 
     if not all(
         isinstance(key, str)
@@ -730,7 +720,7 @@ def _isinstance(
     return isinstance(obj, get_base_class(cls))
 
 
-def is_dataframe(value: Type) -> bool:
+def is_dataframe(value: type) -> bool:
     """Check if the given value is a dataframe.
 
     Args:
@@ -744,7 +734,7 @@ def is_dataframe(value: Type) -> bool:
     return value.__name__ == "DataFrame"
 
 
-def is_valid_var_type(type_: Type) -> bool:
+def is_valid_var_type(type_: type) -> bool:
     """Check if the given type is a valid prop type.
 
     Args:
@@ -756,7 +746,7 @@ def is_valid_var_type(type_: Type) -> bool:
     from reflex.utils import serializers
 
     if is_union(type_):
-        return all((is_valid_var_type(arg) for arg in get_args(type_)))
+        return all(is_valid_var_type(arg) for arg in get_args(type_))
     return (
         _issubclass(type_, StateVar)
         or serializers.has_serializer(type_)
@@ -764,7 +754,7 @@ def is_valid_var_type(type_: Type) -> bool:
     )
 
 
-def is_backend_base_variable(name: str, cls: Type) -> bool:
+def is_backend_base_variable(name: str, cls: type) -> bool:
     """Check if this variable name correspond to a backend variable.
 
     Args:
@@ -821,7 +811,7 @@ def is_backend_base_variable(name: str, cls: Type) -> bool:
     return True
 
 
-def check_type_in_allowed_types(value_type: Type, allowed_types: Iterable) -> bool:
+def check_type_in_allowed_types(value_type: type, allowed_types: Iterable) -> bool:
     """Check that a value type is found in a list of allowed types.
 
     Args:
@@ -863,7 +853,7 @@ def is_encoded_fstring(value: Any) -> bool:
     return isinstance(value, str) and constants.REFLEX_VAR_OPENING_TAG in value
 
 
-def validate_literal(key: str, value: Any, expected_type: Type, comp_name: str):
+def validate_literal(key: str, value: Any, expected_type: type, comp_name: str):
     """Check that a value is a valid literal.
 
     Args:
@@ -1008,14 +998,12 @@ def typehint_issubclass(
             for arg in args
         )
 
-    # Remove this check when Python 3.10 is the minimum supported version
-    if hasattr(types, "UnionType"):
-        provided_type_origin = (
-            Union if provided_type_origin is types.UnionType else provided_type_origin
-        )
-        accepted_type_origin = (
-            Union if accepted_type_origin is types.UnionType else accepted_type_origin
-        )
+    provided_type_origin = (
+        Union if provided_type_origin is types.UnionType else provided_type_origin
+    )
+    accepted_type_origin = (
+        Union if accepted_type_origin is types.UnionType else accepted_type_origin
+    )
 
     # Get type arguments (e.g., [float, int] for dict[float, int])
     provided_args = get_args(possible_subclass)

reflex/vars/base.py

@@ -14,30 +14,24 @@ import re
 import string
 import uuid
 import warnings
+from collections.abc import Callable, Coroutine, Iterable, Mapping, Sequence
 from types import CodeType, FunctionType
-from typing import (
+from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
-    Callable,
     ClassVar,
-    Coroutine,
     Dict,
     FrozenSet,
     Generic,
-    Iterable,
     List,
     Literal,
-    Mapping,
     NoReturn,
     ParamSpec,
     Protocol,
-    Sequence,
     Set,
     Tuple,
-    Type,
     TypeGuard,
     TypeVar,
-    Union,
     cast,
     get_args,
     get_type_hints,
@@ -102,13 +96,13 @@ warnings.filterwarnings("ignore", message="fields may not start with an undersco
 class VarSubclassEntry:
     """Entry for a Var subclass."""
 
-    var_subclass: Type[Var]
-    to_var_subclass: Type[ToOperation]
+    var_subclass: type[Var]
+    to_var_subclass: type[ToOperation]
     python_types: tuple[GenericType, ...]
 
 
 _var_subclasses: list[VarSubclassEntry] = []
-_var_literal_subclasses: list[tuple[Type[LiteralVar], VarSubclassEntry]] = []
+_var_literal_subclasses: list[tuple[type[LiteralVar], VarSubclassEntry]] = []
 
 
 @dataclasses.dataclass(
@@ -137,7 +131,7 @@ class VarData:
     position: Hooks.HookPosition | None = None
 
     # Components that are part of this var
-    components: Tuple[BaseComponent, ...] = dataclasses.field(default_factory=tuple)
+    components: tuple[BaseComponent, ...] = dataclasses.field(default_factory=tuple)
 
     def __init__(
         self,
@@ -284,7 +278,7 @@ class VarData:
         )
 
     @classmethod
-    def from_state(cls, state: Type[BaseState] | str, field_name: str = "") -> VarData:
+    def from_state(cls, state: type[BaseState] | str, field_name: str = "") -> VarData:
         """Set the state of the var.
 
         Args:
@@ -534,7 +528,7 @@ class Var(Generic[VAR_TYPE]):
     @overload
     def _replace(
         self,
-        _var_type: Type[OTHER_VAR_TYPE],
+        _var_type: type[OTHER_VAR_TYPE],
         merge_var_data: VarData | None = None,
         **kwargs: Any,
     ) -> Var[OTHER_VAR_TYPE]: ...
@@ -726,10 +720,10 @@ class Var(Generic[VAR_TYPE]):
         return f"{constants.REFLEX_VAR_OPENING_TAG}{hashed_var}{constants.REFLEX_VAR_CLOSING_TAG}{self._js_expr}"
 
     @overload
-    def to(self, output: Type[str]) -> StringVar: ...
+    def to(self, output: type[str]) -> StringVar: ...
 
     @overload
-    def to(self, output: Type[bool]) -> BooleanVar: ...
+    def to(self, output: type[bool]) -> BooleanVar: ...
 
     @overload
     def to(self, output: type[int]) -> NumberVar[int]: ...
@@ -751,12 +745,12 @@ class Var(Generic[VAR_TYPE]):
 
     @overload
     def to(
-        self, output: Type[ObjectVar], var_type: Type[VAR_INSIDE]
+        self, output: type[ObjectVar], var_type: type[VAR_INSIDE]
     ) -> ObjectVar[VAR_INSIDE]: ...
 
     @overload
     def to(
-        self, output: Type[ObjectVar], var_type: None = None
+        self, output: type[ObjectVar], var_type: None = None
     ) -> ObjectVar[VAR_TYPE]: ...
 
     @overload
@@ -765,13 +759,13 @@ class Var(Generic[VAR_TYPE]):
     @overload
     def to(
         self,
-        output: Type[OUTPUT] | types.GenericType,
+        output: type[OUTPUT] | types.GenericType,
         var_type: types.GenericType | None = None,
     ) -> OUTPUT: ...
 
     def to(
         self,
-        output: Type[OUTPUT] | types.GenericType,
+        output: type[OUTPUT] | types.GenericType,
         var_type: types.GenericType | None = None,
     ) -> Var:
         """Convert the var to a different type.
@@ -1064,6 +1058,16 @@ class Var(Generic[VAR_TYPE]):
 
         return boolify(self)
 
+    def is_none(self) -> BooleanVar:
+        """Check if the var is None.
+
+        Returns:
+            A BooleanVar object representing the result of the check.
+        """
+        from .number import is_not_none_operation
+
+        return ~is_not_none_operation(self)
+
     def is_not_none(self) -> BooleanVar:
         """Check if the var is not None.
 
@@ -1331,7 +1335,7 @@ class Var(Generic[VAR_TYPE]):
                 )
 
             raise VarAttributeError(
-                f"The State var has no attribute '{name}' or may have been annotated wrongly.",
+                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.",
             )
 
         def __bool__(self) -> bool:
@@ -1831,7 +1835,7 @@ class cached_property:  # noqa: N801
                 f"({self._attrname!r} and {name!r})."
             )
 
-    def __get__(self, instance: Any, owner: Type | None = None):
+    def __get__(self, instance: Any, owner: type | None = None):
         """Get the cached property.
 
         Args:
@@ -2134,7 +2138,7 @@ class ComputedVar(Var[RETURN_TYPE]):
 
     def _calculate_static_deps(
         self,
-        deps: Union[list[str | Var], dict[str | None, set[str]]] | None = None,
+        deps: list[str | Var] | dict[str | None, set[str]] | None = None,
     ) -> dict[str | None, set[str]]:
         """Calculate the static dependencies of the computed var from user input or existing dependencies.
 
@@ -2269,56 +2273,56 @@ class ComputedVar(Var[RETURN_TYPE]):
     def __get__(
         self: ComputedVar[bool],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> BooleanVar: ...
 
     @overload
     def __get__(
         self: ComputedVar[int] | ComputedVar[float],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> NumberVar: ...
 
     @overload
     def __get__(
         self: ComputedVar[str],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> StringVar: ...
 
     @overload
     def __get__(
         self: ComputedVar[MAPPING_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[MAPPING_TYPE]: ...
 
     @overload
     def __get__(
         self: ComputedVar[list[LIST_INSIDE]],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ArrayVar[list[LIST_INSIDE]]: ...
 
     @overload
     def __get__(
         self: ComputedVar[tuple[LIST_INSIDE, ...]],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ArrayVar[tuple[LIST_INSIDE, ...]]: ...
 
     @overload
     def __get__(
         self: ComputedVar[BASE_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[BASE_TYPE]: ...
 
     @overload
     def __get__(
         self: ComputedVar[SQLA_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[SQLA_TYPE]: ...
 
     if TYPE_CHECKING:
@@ -2329,12 +2333,12 @@ class ComputedVar(Var[RETURN_TYPE]):
         ) -> ObjectVar[DATACLASS_TYPE]: ...
 
     @overload
-    def __get__(self, instance: None, owner: Type) -> ComputedVar[RETURN_TYPE]: ...
+    def __get__(self, instance: None, owner: type) -> ComputedVar[RETURN_TYPE]: ...
 
     @overload
-    def __get__(self, instance: BaseState, owner: Type) -> RETURN_TYPE: ...
+    def __get__(self, instance: BaseState, owner: type) -> RETURN_TYPE: ...
 
-    def __get__(self, instance: BaseState | None, owner: Type):
+    def __get__(self, instance: BaseState | None, owner: type):
         """Get the ComputedVar value.
 
         If the value is already cached on the instance, return the cached value.
@@ -2390,7 +2394,7 @@ class ComputedVar(Var[RETURN_TYPE]):
 
     def _deps(
         self,
-        objclass: Type[BaseState],
+        objclass: type[BaseState],
         obj: FunctionType | CodeType | None = None,
     ) -> dict[str, set[str]]:
         """Determine var dependencies of this ComputedVar.
@@ -2448,7 +2452,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         with contextlib.suppress(AttributeError):
             delattr(instance, self._cache_attr)
 
-    def add_dependency(self, objclass: Type[BaseState], dep: Var):
+    def add_dependency(self, objclass: type[BaseState], dep: Var):
         """Explicitly add a dependency to the ComputedVar.
 
         After adding the dependency, when the `dep` changes, this computed var
@@ -2479,7 +2483,7 @@ class ComputedVar(Var[RETURN_TYPE]):
             f"field name, got {dep!r}."
         )
 
-    def _determine_var_type(self) -> Type:
+    def _determine_var_type(self) -> type:
         """Get the type of the var.
 
         Returns:
@@ -2491,7 +2495,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         return Any  # pyright: ignore [reportReturnType]
 
     @property
-    def __class__(self) -> Type:
+    def __class__(self) -> type:
         """Get the class of the var.
 
         Returns:
@@ -2536,56 +2540,56 @@ class AsyncComputedVar(ComputedVar[RETURN_TYPE]):
     def __get__(
         self: AsyncComputedVar[bool],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> BooleanVar: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[int] | ComputedVar[float],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> NumberVar: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[str],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> StringVar: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[MAPPING_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[MAPPING_TYPE]: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[list[LIST_INSIDE]],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ArrayVar[list[LIST_INSIDE]]: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[tuple[LIST_INSIDE, ...]],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ArrayVar[tuple[LIST_INSIDE, ...]]: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[BASE_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[BASE_TYPE]: ...
 
     @overload
     def __get__(
         self: AsyncComputedVar[SQLA_TYPE],
         instance: None,
-        owner: Type,
+        owner: type,
     ) -> ObjectVar[SQLA_TYPE]: ...
 
     if TYPE_CHECKING:
@@ -2596,11 +2600,11 @@ class AsyncComputedVar(ComputedVar[RETURN_TYPE]):
         ) -> ObjectVar[DATACLASS_TYPE]: ...
 
     @overload
-    def __get__(self, instance: None, owner: Type) -> AsyncComputedVar[RETURN_TYPE]: ...
+    def __get__(self, instance: None, owner: type) -> AsyncComputedVar[RETURN_TYPE]: ...
 
     @overload
     def __get__(
-        self, instance: BaseState, owner: Type
+        self, instance: BaseState, owner: type
     ) -> Coroutine[None, None, RETURN_TYPE]: ...
 
     def __get__(
@@ -2771,7 +2775,7 @@ class CustomVarOperationReturn(Var[RETURN]):
     def create(
         cls,
         js_expression: str,
-        _var_type: Type[RETURN] | None = None,
+        _var_type: type[RETURN] | None = None,
         _var_data: VarData | None = None,
     ) -> CustomVarOperationReturn[RETURN]:
         """Create a CustomVarOperation.
@@ -2793,7 +2797,7 @@ class CustomVarOperationReturn(Var[RETURN]):
 
 def var_operation_return(
     js_expression: str,
-    var_type: Type[RETURN] | GenericType | None = None,
+    var_type: type[RETURN] | GenericType | None = None,
     var_data: VarData | None = None,
 ) -> CustomVarOperationReturn[RETURN]:
     """Shortcut for creating a CustomVarOperationReturn.
@@ -2924,7 +2928,7 @@ class LiteralNoneVar(LiteralVar, NoneVar):
         )
 
 
-def get_to_operation(var_subclass: Type[Var]) -> Type[ToOperation]:
+def get_to_operation(var_subclass: type[Var]) -> type[ToOperation]:
     """Get the ToOperation class for a given Var subclass.
 
     Args:
@@ -3169,11 +3173,11 @@ def resolve_generic_type_with_mapping(
         return generic_type
 
     mapping_for_older_python = {
-        list: List,
-        set: Set,
-        dict: Dict,
-        tuple: Tuple,
-        frozenset: FrozenSet,
+        list: List,  # noqa: UP006
+        set: Set,  # noqa: UP006
+        dict: Dict,  # noqa: UP006
+        tuple: Tuple,  # noqa: UP006
+        frozenset: FrozenSet,  # noqa: UP006
     }
 
     return mapping_for_older_python.get(generic_origin, generic_origin)[

reflex/vars/dep_tracking.py

@@ -8,7 +8,7 @@ import dis
 import enum
 import inspect
 from types import CellType, CodeType, FunctionType
-from typing import TYPE_CHECKING, Any, ClassVar, Type, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from reflex.utils.exceptions import VarValueError
 
@@ -50,16 +50,16 @@ class DependencyTracker:
     """State machine for identifying state attributes that are accessed by a function."""
 
     func: FunctionType | CodeType = dataclasses.field()
-    state_cls: Type[BaseState] = dataclasses.field()
+    state_cls: type[BaseState] = dataclasses.field()
 
     dependencies: dict[str, set[str]] = dataclasses.field(default_factory=dict)
 
     scan_status: ScanStatus = dataclasses.field(default=ScanStatus.SCANNING)
     top_of_stack: str | None = dataclasses.field(default=None)
 
-    tracked_locals: dict[str, Type[BaseState]] = dataclasses.field(default_factory=dict)
+    tracked_locals: dict[str, type[BaseState]] = dataclasses.field(default_factory=dict)
 
-    _getting_state_class: Type[BaseState] | None = dataclasses.field(default=None)
+    _getting_state_class: type[BaseState] | None = dataclasses.field(default=None)
     _getting_var_instructions: list[dis.Instruction] = dataclasses.field(
         default_factory=list
     )