reflex 0.8.12a1__py3-none-any.whl → 0.8.13a1__py3-none-any.whl

reflex/utils/prerequisites.py

@@ -269,25 +269,100 @@ def get_compiled_app(
     return app_module
 
 
+def _can_colorize() -> bool:
+    """Check if the output can be colorized.
+
+    Copied from _colorize.can_colorize.
+
+    https://raw.githubusercontent.com/python/cpython/refs/heads/main/Lib/_colorize.py
+
+    Returns:
+        If the output can be colorized
+    """
+    import io
+    import os
+
+    def _safe_getenv(k: str, fallback: str | None = None) -> str | None:
+        """Exception-safe environment retrieval. See gh-128636.
+
+        Args:
+            k: The environment variable key.
+            fallback: The fallback value if the environment variable is not set.
+
+        Returns:
+            The value of the environment variable or the fallback value.
+        """
+        try:
+            return os.environ.get(k, fallback)
+        except Exception:
+            return fallback
+
+    file = sys.stdout
+
+    if not sys.flags.ignore_environment:
+        if _safe_getenv("PYTHON_COLORS") == "0":
+            return False
+        if _safe_getenv("PYTHON_COLORS") == "1":
+            return True
+    if _safe_getenv("NO_COLOR"):
+        return False
+    if _safe_getenv("FORCE_COLOR"):
+        return True
+    if _safe_getenv("TERM") == "dumb":
+        return False
+
+    if not hasattr(file, "fileno"):
+        return False
+
+    if sys.platform == "win32":
+        try:
+            import nt
+
+            if not nt._supports_virtual_terminal():
+                return False
+        except (ImportError, AttributeError):
+            return False
+
+    try:
+        return os.isatty(file.fileno())
+    except io.UnsupportedOperation:
+        return hasattr(file, "isatty") and file.isatty()
+
+
 def compile_or_validate_app(
     compile: bool = False,
     check_if_schema_up_to_date: bool = False,
     prerender_routes: bool = False,
-):
+) -> bool:
     """Compile or validate the app module based on the default config.
 
     Args:
         compile: Whether to compile the app.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
         prerender_routes: Whether to prerender routes.
+
+    Returns:
+        True if the app was successfully compiled or validated, False otherwise.
     """
-    if compile:
-        get_compiled_app(
-            check_if_schema_up_to_date=check_if_schema_up_to_date,
-            prerender_routes=prerender_routes,
-        )
+    try:
+        if compile:
+            get_compiled_app(
+                check_if_schema_up_to_date=check_if_schema_up_to_date,
+                prerender_routes=prerender_routes,
+            )
+        else:
+            get_and_validate_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
+    except Exception as e:
+        import traceback
+
+        try:
+            colorize = _can_colorize()
+            traceback.print_exception(e, colorize=colorize)  # pyright: ignore[reportCallIssue]
+        except Exception:
+            traceback.print_exception(e)
+        return False
     else:
-        get_and_validate_app(check_if_schema_up_to_date=check_if_schema_up_to_date)
+        return True
 
 
 def get_redis() -> Redis | None:

reflex/utils/serializers.py

@@ -20,7 +20,7 @@ from pydantic import BaseModel as BaseModelV2
 from pydantic.v1 import BaseModel as BaseModelV1
 
 from reflex.base import Base
-from reflex.constants.colors import Color, format_color
+from reflex.constants.colors import Color
 from reflex.utils import console, types
 
 # Mapping from type to a serializer.
@@ -413,8 +413,8 @@ def serialize_decimal(value: decimal.Decimal) -> float:
     return float(value)
 
 
-@serializer(to=str)
-def serialize_color(color: Color) -> str:
+@serializer(to=dict)
+def serialize_color(color: Color) -> dict:
     """Serialize a color.
 
     Args:
@@ -423,7 +423,11 @@ def serialize_color(color: Color) -> str:
     Returns:
         The serialized color.
     """
-    return format_color(color.color, color.shade, color.alpha)
+    return {
+        "color": color.color,
+        "shade": color.shade,
+        "alpha": color.alpha,
+    }
 
 
 with contextlib.suppress(ImportError):

reflex/utils/token_manager.py

@@ -66,6 +66,16 @@ class TokenManager(ABC):
 
         return LocalTokenManager()
 
+    async def disconnect_all(self):
+        """Disconnect all tracked tokens when the server is going down."""
+        token_sid_pairs: set[tuple[str, str]] = set(self.token_to_sid.items())
+        token_sid_pairs.update(
+            ((token, sid) for sid, token in self.sid_to_token.items())
+        )
+        # Perform the disconnection logic here
+        for token, sid in token_sid_pairs:
+            await self.disconnect_token(token, sid)
+
 
 class LocalTokenManager(TokenManager):
     """Token manager using local in-memory dictionaries (single worker)."""

reflex/utils/types.py

@@ -6,6 +6,7 @@ import dataclasses
 import sys
 import types
 from collections.abc import Callable, Iterable, Mapping, Sequence
+from enum import Enum
 from functools import cached_property, lru_cache
 from types import GenericAlias
 from typing import (  # noqa: UP035
@@ -1241,6 +1242,7 @@ IMMUTABLE_TYPES = (
     frozenset,
     tuple,
     type(None),
+    Enum,
 )
 
 

reflex/vars/__init__.py

@@ -1,28 +1,58 @@
 """Immutable-Based Var System."""
 
-from .base import BaseStateMeta as BaseStateMeta
-from .base import EvenMoreBasicBaseState as EvenMoreBasicBaseState
-from .base import Field as Field
-from .base import LiteralVar as LiteralVar
-from .base import Var as Var
-from .base import VarData as VarData
-from .base import field as field
-from .base import get_unique_variable_name as get_unique_variable_name
-from .base import get_uuid_string_var as get_uuid_string_var
-from .base import var_operation as var_operation
-from .base import var_operation_return as var_operation_return
-from .datetime import DateTimeVar as DateTimeVar
-from .function import FunctionStringVar as FunctionStringVar
-from .function import FunctionVar as FunctionVar
-from .function import VarOperationCall as VarOperationCall
-from .number import BooleanVar as BooleanVar
-from .number import LiteralBooleanVar as LiteralBooleanVar
-from .number import LiteralNumberVar as LiteralNumberVar
-from .number import NumberVar as NumberVar
-from .object import LiteralObjectVar as LiteralObjectVar
-from .object import ObjectVar as ObjectVar
-from .sequence import ArrayVar as ArrayVar
-from .sequence import ConcatVarOperation as ConcatVarOperation
-from .sequence import LiteralArrayVar as LiteralArrayVar
-from .sequence import LiteralStringVar as LiteralStringVar
-from .sequence import StringVar as StringVar
+from .base import (
+    BaseStateMeta,
+    EvenMoreBasicBaseState,
+    Field,
+    LiteralVar,
+    Var,
+    VarData,
+    field,
+    get_unique_variable_name,
+    get_uuid_string_var,
+    var_operation,
+    var_operation_return,
+)
+from .color import ColorVar, LiteralColorVar
+from .datetime import DateTimeVar
+from .function import FunctionStringVar, FunctionVar, VarOperationCall
+from .number import BooleanVar, LiteralBooleanVar, LiteralNumberVar, NumberVar
+from .object import LiteralObjectVar, ObjectVar
+from .sequence import (
+    ArrayVar,
+    ConcatVarOperation,
+    LiteralArrayVar,
+    LiteralStringVar,
+    StringVar,
+)
+
+__all__ = [
+    "ArrayVar",
+    "BaseStateMeta",
+    "BooleanVar",
+    "ColorVar",
+    "ConcatVarOperation",
+    "DateTimeVar",
+    "EvenMoreBasicBaseState",
+    "Field",
+    "FunctionStringVar",
+    "FunctionVar",
+    "LiteralArrayVar",
+    "LiteralBooleanVar",
+    "LiteralColorVar",
+    "LiteralNumberVar",
+    "LiteralObjectVar",
+    "LiteralStringVar",
+    "LiteralVar",
+    "NumberVar",
+    "ObjectVar",
+    "StringVar",
+    "Var",
+    "VarData",
+    "VarOperationCall",
+    "field",
+    "get_unique_variable_name",
+    "get_uuid_string_var",
+    "var_operation",
+    "var_operation_return",
+]

reflex/vars/base.py

@@ -18,21 +18,16 @@ from collections.abc import Callable, Coroutine, Iterable, Mapping, Sequence
 from dataclasses import _MISSING_TYPE, MISSING
 from decimal import Decimal
 from types import CodeType, FunctionType
-from typing import (  # noqa: UP035
+from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
     ClassVar,
-    Dict,
-    FrozenSet,
     Generic,
-    List,
     Literal,
     NoReturn,
     ParamSpec,
     Protocol,
-    Set,
-    Tuple,
     TypeGuard,
     TypeVar,
     cast,
@@ -78,8 +73,10 @@ from reflex.utils.types import (
 
 if TYPE_CHECKING:
     from reflex.components.component import BaseComponent
+    from reflex.constants.colors import Color
     from reflex.state import BaseState
 
+    from .color import LiteralColorVar
     from .number import BooleanVar, LiteralBooleanVar, LiteralNumberVar, NumberVar
     from .object import LiteralObjectVar, ObjectVar
     from .sequence import ArrayVar, LiteralArrayVar, LiteralStringVar, StringVar
@@ -642,6 +639,14 @@ class Var(Generic[VAR_TYPE], metaclass=MetaclassVar):
         _var_data: VarData | None = None,
     ) -> LiteralNumberVar[Decimal]: ...
 
+    @overload
+    @classmethod
+    def create(  # pyright: ignore [reportOverlappingOverload]
+        cls,
+        value: Color,
+        _var_data: VarData | None = None,
+    ) -> LiteralColorVar: ...
+
     @overload
     @classmethod
     def create(  # pyright: ignore [reportOverlappingOverload]
@@ -3080,7 +3085,8 @@ def transform(fn: Callable[[Var], Var]) -> Callable[[Var], Var]:
         TypeError: If the Var return type does not have a generic type.
         ValueError: If a function for the generic type is already registered.
     """
-    return_type = fn.__annotations__["return"]
+    types = get_type_hints(fn)
+    return_type = types["return"]
 
     origin = get_origin(return_type)
 
@@ -3105,101 +3111,6 @@ def transform(fn: Callable[[Var], Var]) -> Callable[[Var], Var]:
     return fn
 
 
-def generic_type_to_actual_type_map(
-    generic_type: GenericType, actual_type: GenericType
-) -> dict[TypeVar, GenericType]:
-    """Map the generic type to the actual type.
-
-    Args:
-        generic_type: The generic type.
-        actual_type: The actual type.
-
-    Returns:
-        The mapping of type variables to actual types.
-
-    Raises:
-        TypeError: If the generic type and actual type do not match.
-        TypeError: If the number of generic arguments and actual arguments do not match.
-    """
-    generic_origin = get_origin(generic_type) or generic_type
-    actual_origin = get_origin(actual_type) or actual_type
-
-    if generic_origin is not actual_origin:
-        if isinstance(generic_origin, TypeVar):
-            return {generic_origin: 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):
-        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 {
-        k: v
-        for generic_arg, actual_arg in zip(generic_args, actual_args, strict=True)
-        for k, v in generic_type_to_actual_type_map(generic_arg, actual_arg).items()
-    }
-
-
-def resolve_generic_type_with_mapping(
-    generic_type: GenericType, type_mapping: dict[TypeVar, GenericType]
-):
-    """Resolve a generic type with a type mapping.
-
-    Args:
-        generic_type: The generic type.
-        type_mapping: The type mapping.
-
-    Returns:
-        The resolved generic type.
-    """
-    if isinstance(generic_type, TypeVar):
-        return type_mapping.get(generic_type, generic_type)
-
-    generic_origin = get_origin(generic_type) or generic_type
-
-    generic_args = get_args(generic_type)
-
-    if not generic_args:
-        return generic_type
-
-    mapping_for_older_python = {
-        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)[
-        tuple(
-            resolve_generic_type_with_mapping(arg, type_mapping) for arg in generic_args
-        )
-    ]
-
-
-def resolve_arg_type_from_return_type(
-    arg_type: GenericType, return_type: GenericType, actual_return_type: GenericType
-) -> GenericType:
-    """Resolve the argument type from the return type.
-
-    Args:
-        arg_type: The argument type.
-        return_type: The return type.
-        actual_return_type: The requested return type.
-
-    Returns:
-        The argument type without the generics that are resolved.
-    """
-    return resolve_generic_type_with_mapping(
-        arg_type, generic_type_to_actual_type_map(return_type, actual_return_type)
-    )
-
-
 def dispatch(
     field_name: str,
     var_data: VarData,
@@ -3227,11 +3138,12 @@ def dispatch(
 
     if result_origin_var_type in dispatchers:
         fn = dispatchers[result_origin_var_type]
-        fn_first_arg_type = next(
-            iter(inspect.signature(fn).parameters.values())
-        ).annotation
+        fn_types = get_type_hints(fn)
+        fn_first_arg_type = fn_types.get(
+            next(iter(inspect.signature(fn).parameters.values())).name, Any
+        )
 
-        fn_return = inspect.signature(fn).return_annotation
+        fn_return = fn_types.get("return", Any)
 
         fn_return_origin = get_origin(fn_return) or fn_return
 
@@ -3257,22 +3169,17 @@ def dispatch(
             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]
 
         var = (
             Var(
                 field_name,
                 _var_data=var_data,
-                _var_type=resolve_arg_type_from_return_type(
-                    arg_type, fn_return_type, result_var_type
-                ),
+                _var_type=fn_return_type,
             ).guess_type()
             if existing_var is None
             else existing_var._replace(
-                _var_type=resolve_arg_type_from_return_type(
-                    arg_type, fn_return_type, result_var_type
-                ),
+                _var_type=fn_return_type,
                 _var_data=var_data,
                 _js_expr=field_name,
             ).guess_type()

reflex/vars/color.py

@@ -0,0 +1,214 @@
+"""Vars for colors."""
+
+import dataclasses
+
+from reflex.constants.colors import Color
+from reflex.vars.base import (
+    CachedVarOperation,
+    LiteralVar,
+    Var,
+    VarData,
+    cached_property_no_lock,
+    get_python_literal,
+    transform,
+)
+from reflex.vars.number import BooleanVar, NumberVar, ternary_operation
+from reflex.vars.object import LiteralObjectVar
+from reflex.vars.sequence import ConcatVarOperation, LiteralStringVar, StringVar
+
+
+@transform
+def evaluate_color(js_dict: Var[dict]) -> Var[Color]:
+    """Evaluate a color var.
+
+    Args:
+        js_dict: The color var as a dict.
+
+    Returns:
+        The color var as a string.
+    """
+    js_color_dict = js_dict.to(dict)
+    str_part = ConcatVarOperation.create(
+        LiteralStringVar.create("var(--"),
+        js_color_dict.color,
+        LiteralStringVar.create("-"),
+        ternary_operation(
+            js_color_dict.alpha,
+            LiteralStringVar.create("a"),
+            LiteralStringVar.create(""),
+        ),
+        js_color_dict.shade.to_string(use_json=False),
+        LiteralStringVar.create(")"),
+    )
+    return js_dict._replace(
+        _js_expr=f"Object.assign(new String({str_part!s}), {js_dict!s})",
+        _var_type=Color,
+    )
+
+
+class ColorVar(StringVar[Color], python_types=Color):
+    """Base class for immutable color vars."""
+
+    @property
+    def color(self) -> StringVar:
+        """Get the color of the color var.
+
+        Returns:
+            The color of the color var.
+        """
+        return self.to(dict).color.to(str)
+
+    @property
+    def alpha(self) -> BooleanVar:
+        """Get the alpha of the color var.
+
+        Returns:
+            The alpha of the color var.
+        """
+        return self.to(dict).alpha.to(bool)
+
+    @property
+    def shade(self) -> NumberVar:
+        """Get the shade of the color var.
+
+        Returns:
+            The shade of the color var.
+        """
+        return self.to(dict).shade.to(int)
+
+
+@dataclasses.dataclass(
+    eq=False,
+    frozen=True,
+    slots=True,
+)
+class LiteralColorVar(CachedVarOperation, LiteralVar, ColorVar):
+    """Base class for immutable literal color vars."""
+
+    _var_value: Color = dataclasses.field(default_factory=lambda: Color(color="black"))
+
+    @classmethod
+    def create(
+        cls,
+        value: Color,
+        _var_type: type[Color] | None = None,
+        _var_data: VarData | None = None,
+    ) -> ColorVar:
+        """Create a var from a string value.
+
+        Args:
+            value: The value to create the var from.
+            _var_type: The type of the var.
+            _var_data: Additional hooks and imports associated with the Var.
+
+        Returns:
+            The var.
+        """
+        return cls(
+            _js_expr="",
+            _var_type=_var_type or Color,
+            _var_data=_var_data,
+            _var_value=value,
+        )
+
+    def __hash__(self) -> int:
+        """Get the hash of the var.
+
+        Returns:
+            The hash of the var.
+        """
+        return hash(
+            (
+                self.__class__.__name__,
+                self._var_value.color,
+                self._var_value.alpha,
+                self._var_value.shade,
+            )
+        )
+
+    @cached_property_no_lock
+    def _cached_var_name(self) -> str:
+        """The name of the var.
+
+        Returns:
+            The name of the var.
+        """
+        alpha = self._var_value.alpha
+        alpha = (
+            ternary_operation(
+                alpha,
+                LiteralStringVar.create("a"),
+                LiteralStringVar.create(""),
+            )
+            if isinstance(alpha, Var)
+            else LiteralStringVar.create("a" if alpha else "")
+        )
+
+        shade = self._var_value.shade
+        shade = (
+            shade.to_string(use_json=False)
+            if isinstance(shade, Var)
+            else LiteralStringVar.create(str(shade))
+        )
+        string_part = str(
+            ConcatVarOperation.create(
+                LiteralStringVar.create("var(--"),
+                self._var_value.color,
+                LiteralStringVar.create("-"),
+                alpha,
+                shade,
+                LiteralStringVar.create(")"),
+            )
+        )
+        dict_part = LiteralObjectVar.create(
+            {
+                "color": self._var_value.color,
+                "alpha": self._var_value.alpha,
+                "shade": self._var_value.shade,
+            }
+        )
+        return f"Object.assign(new String({string_part!s}), {dict_part!s})"
+
+    @cached_property_no_lock
+    def _cached_get_all_var_data(self) -> VarData | None:
+        """Get all the var data.
+
+        Returns:
+            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,
+                )
+            ],
+            self._var_data,
+        )
+
+    def json(self) -> str:
+        """Get the JSON representation of the var.
+
+        Returns:
+            The JSON representation of the var.
+
+        Raises:
+            TypeError: If the color is not a valid color.
+        """
+        color, alpha, shade = map(
+            get_python_literal,
+            (self._var_value.color, self._var_value.alpha, self._var_value.shade),
+        )
+        if color is None or alpha is None or shade is None:
+            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)
+        ):
+            msg = "Color is not a valid color."
+            raise TypeError(msg)
+        return f"var(--{color}-{'a' if alpha else ''}{shade})"

reflex/vars/number.py

@@ -909,7 +909,7 @@ def equal_operation(lhs: Var, rhs: Var):
     Returns:
         The result of the comparison.
     """
-    return f"({lhs} === {rhs})"
+    return f"({lhs}?.valueOf?.() === {rhs}?.valueOf?.())"
 
 
 @comparison_operator
@@ -923,7 +923,7 @@ def not_equal_operation(lhs: Var, rhs: Var):
     Returns:
         The result of the comparison.
     """
-    return f"({lhs} !== {rhs})"
+    return f"({lhs}?.valueOf?.() !== {rhs}?.valueOf?.())"
 
 
 @var_operation