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

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

reflex/vars/sequence.py

@@ -15,7 +15,6 @@ from typing_extensions import TypeVar as TypingExtensionsTypeVar
 
 from reflex import constants
 from reflex.constants.base import REFLEX_VAR_OPENING_TAG
-from reflex.constants.colors import Color
 from reflex.utils import types
 from reflex.utils.exceptions import VarTypeError
 from reflex.utils.types import GenericType, get_origin
@@ -29,7 +28,6 @@ from .base import (
     _global_vars,
     cached_property_no_lock,
     figure_out_type,
-    get_python_literal,
     get_unique_variable_name,
     unionize,
     var_operation,
@@ -40,7 +38,6 @@ from .number import (
     LiteralNumberVar,
     NumberVar,
     raise_unsupported_operand_types,
-    ternary_operation,
 )
 
 if TYPE_CHECKING:
@@ -1743,139 +1740,6 @@ def array_concat_operation(
     )
 
 
-class ColorVar(StringVar[Color], python_types=Color):
-    """Base class for immutable color vars."""
-
-
-@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))
-        )
-        return str(
-            ConcatVarOperation.create(
-                LiteralStringVar.create("var(--"),
-                self._var_value.color,
-                LiteralStringVar.create("-"),
-                alpha,
-                shade,
-                LiteralStringVar.create(")"),
-            )
-        )
-
-    @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})"
-
-
 class RangeVar(ArrayVar[Sequence[int]], python_types=range):
     """Base class for immutable range vars."""
 

{reflex-0.8.12a1.dist-info → reflex-0.8.13.dist-info}/METADATA

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