reflex 0.7.1a4__py3-none-any.whl → 0.7.2a2__py3-none-any.whl

reflex/utils/pyi_generator.py

@@ -15,7 +15,7 @@ from inspect import getfullargspec
 from itertools import chain
 from multiprocessing import Pool, cpu_count
 from pathlib import Path
-from types import ModuleType, SimpleNamespace
+from types import ModuleType, SimpleNamespace, UnionType
 from typing import Any, Callable, Iterable, Sequence, Type, get_args, get_origin
 
 from reflex.components.component import Component
@@ -61,9 +61,11 @@ DEFAULT_TYPING_IMPORTS = {
     "Callable",
     "Dict",
     # "List",
+    "Sequence",
     "Literal",
     "Optional",
     "Union",
+    "Annotated",
 }
 
 # TODO: fix import ordering and unused imports with ruff later
@@ -144,17 +146,17 @@ def _get_type_hint(
             ]
             res_args.sort()
             if len(res_args) == 1:
-                return f"Optional[{res_args[0]}]"
+                return f"{res_args[0]} | None"
             else:
-                res = f"Union[{', '.join(res_args)}]"
-                return f"Optional[{res}]"
+                res = f"{' | '.join(res_args)}"
+                return f"{res} | None"
 
         res_args = [
             _get_type_hint(arg, type_hint_globals, rx_types.is_optional(arg))
             for arg in value.__args__
         ]
         res_args.sort()
-        return f"Union[{', '.join(res_args)}]"
+        return f"{' | '.join(res_args)}"
 
     if args:
         inner_container_type_args = (
@@ -192,8 +194,8 @@ def _get_type_hint(
                 if arg is not type(None)
             ]
             if len(types) > 1:
-                res = ", ".join(sorted(types))
-                res = f"Union[{res}]"
+                res = " | ".join(sorted(types))
+
     elif isinstance(value, str):
         ev = eval(value, type_hint_globals)
         if rx_types.is_optional(ev):
@@ -204,7 +206,7 @@ def _get_type_hint(
                 _get_type_hint(arg, type_hint_globals, rx_types.is_optional(arg))
                 for arg in ev.__args__
             ]
-            return f"Union[{', '.join(res)}]"
+            return f"{' | '.join(res)}"
         res = (
             _get_type_hint(ev, type_hint_globals, is_optional=False)
             if ev.__name__ == "Var"
@@ -212,8 +214,8 @@ def _get_type_hint(
         )
     else:
         res = value.__name__
-    if is_optional and not res.startswith("Optional"):
-        res = f"Optional[{res}]"
+    if is_optional and not res.startswith("Optional") and not res.endswith("| None"):
+        res = f"{res} | None"
     return res
 
 
@@ -399,6 +401,8 @@ def type_to_ast(typ: Any, cls: type) -> ast.AST:
         return ast.Name(id="None")
 
     origin = get_origin(typ)
+    if origin is UnionType:
+        origin = typing.Union
 
     # Handle plain types (int, str, custom classes, etc.)
     if origin is None:
@@ -419,7 +423,7 @@ def type_to_ast(typ: Any, cls: type) -> ast.AST:
         return ast.Name(id=str(typ))
 
     # Get the base type name (List, Dict, Optional, etc.)
-    base_name = origin._name if hasattr(origin, "_name") else origin.__name__
+    base_name = getattr(origin, "_name", origin.__name__)
 
     # Get type arguments
     args = get_args(typ)
@@ -431,7 +435,7 @@ def type_to_ast(typ: Any, cls: type) -> ast.AST:
     # Convert all type arguments recursively
     arg_nodes = [type_to_ast(arg, cls) for arg in args]
 
-    # Special case for single-argument types (like List[T] or Optional[T])
+    # Special case for single-argument types (like list[T] or Optional[T])
     if len(arg_nodes) == 1:
         slice_value = arg_nodes[0]
     else:
@@ -525,12 +529,14 @@ def _generate_component_create_functiondef(
             ]
 
             # Create EventType using the joined string
-            return ast.Name(
-                id=f"Union[{', '.join(map(ast.unparse, all_count_args_type))}]"
-            )
+            return ast.Name(id=f"{' | '.join(map(ast.unparse, all_count_args_type))}")
 
-        if isinstance(annotation, str) and annotation.startswith("Tuple["):
-            inside_of_tuple = annotation.removeprefix("Tuple[").removesuffix("]")
+        if isinstance(annotation, str) and annotation.lower().startswith("tuple["):
+            inside_of_tuple = (
+                annotation.removeprefix("tuple[")
+                .removeprefix("Tuple[")
+                .removesuffix("]")
+            )
 
             if inside_of_tuple == "()":
                 return ast.Name(id="EventType[()]")
@@ -566,9 +572,7 @@ def _generate_component_create_functiondef(
                 for i in range(len(arguments) + 1)
             ]
 
-            return ast.Name(
-                id=f"Union[{', '.join(map(ast.unparse, all_count_args_type))}]"
-            )
+            return ast.Name(id=f"{' | '.join(map(ast.unparse, all_count_args_type))}")
         return ast.Name(id="EventType[Any]")
 
     event_triggers = clz().get_event_triggers()
@@ -882,6 +886,12 @@ class StubGenerator(ast.NodeTransformer):
         call_definition = None
         for child in node.body[:]:
             found_call = False
+            if (
+                isinstance(child, ast.AnnAssign)
+                and isinstance(child.target, ast.Name)
+                and child.target.id.startswith("_")
+            ):
+                node.body.remove(child)
             if isinstance(child, ast.Assign):
                 for target in child.targets[:]:
                     if isinstance(target, ast.Name) and target.id == "__call__":
@@ -1190,8 +1200,9 @@ class PyiGenerator:
             self._scan_files_multiprocess(file_targets)
 
         # Fix generated pyi files with ruff.
-        subprocess.run(["ruff", "format", *self.written_files])
-        subprocess.run(["ruff", "check", "--fix", *self.written_files])
+        if self.written_files:
+            subprocess.run(["ruff", "format", *self.written_files])
+            subprocess.run(["ruff", "check", "--fix", *self.written_files])
 
         # For some reason, we need to format the __init__.pyi files again after fixing...
         init_files = [f for f in self.written_files if "/__init__.pyi" in f]

reflex/utils/serializers.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import contextlib
 import dataclasses
 import functools
+import inspect
 import json
 import warnings
 from datetime import date, datetime, time, timedelta
@@ -13,24 +14,23 @@ from pathlib import Path
 from typing import (
     Any,
     Callable,
-    List,
     Literal,
-    Optional,
+    Sequence,
     Set,
-    Tuple,
     Type,
     TypeVar,
     Union,
     get_type_hints,
     overload,
 )
+from uuid import UUID
 
 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.utils import types
+from reflex.utils import console, types
 
 # Mapping from type to a serializer.
 # The serializer should convert the type to a JSON object.
@@ -50,6 +50,7 @@ SERIALIZED_FUNCTION = TypeVar("SERIALIZED_FUNCTION", bound=Serializer)
 def serializer(
     fn: None = None,
     to: Type[SerializedType] | None = None,
+    overwrite: bool | None = None,
 ) -> Callable[[SERIALIZED_FUNCTION], SERIALIZED_FUNCTION]: ...
 
 
@@ -57,18 +58,21 @@ def serializer(
 def serializer(
     fn: SERIALIZED_FUNCTION,
     to: Type[SerializedType] | None = None,
+    overwrite: bool | None = None,
 ) -> SERIALIZED_FUNCTION: ...
 
 
 def serializer(
     fn: SERIALIZED_FUNCTION | None = None,
     to: Any = None,
+    overwrite: bool | None = None,
 ) -> SERIALIZED_FUNCTION | Callable[[SERIALIZED_FUNCTION], SERIALIZED_FUNCTION]:
     """Decorator to add a serializer for a given type.
 
     Args:
         fn: The function to decorate.
         to: The type returned by the serializer. If this is `str`, then any Var created from this type will be treated as a string.
+        overwrite: Whether to overwrite the existing serializer.
 
     Returns:
         The decorated function.
@@ -88,9 +92,24 @@ def serializer(
 
         # Make sure the type is not already registered.
         registered_fn = SERIALIZERS.get(type_)
-        if registered_fn is not None and registered_fn != fn:
-            raise ValueError(
-                f"Serializer for type {type_} is already registered as {registered_fn.__qualname__}."
+        if registered_fn is not None and registered_fn != fn and overwrite is not True:
+            message = f"Overwriting serializer for type {type_} from {registered_fn.__module__}:{registered_fn.__qualname__} to {fn.__module__}:{fn.__qualname__}."
+            if overwrite is False:
+                raise ValueError(message)
+            caller_frame = next(
+                filter(
+                    lambda frame: frame.filename != __file__,
+                    inspect.getouterframes(inspect.currentframe()),
+                ),
+                None,
+            )
+            file_info = (
+                f"(at {caller_frame.filename}:{caller_frame.lineno})"
+                if caller_frame
+                else ""
+            )
+            console.warn(
+                f"{message} Call rx.serializer with `overwrite=True` if this is intentional. {file_info}"
             )
 
         to_type = to or type_hints.get("return")
@@ -115,22 +134,22 @@ def serializer(
 @overload
 def serialize(
     value: Any, get_type: Literal[True]
-) -> Tuple[Optional[SerializedType], Optional[types.GenericType]]: ...
+) -> tuple[SerializedType | None, types.GenericType | None]: ...
 
 
 @overload
-def serialize(value: Any, get_type: Literal[False]) -> Optional[SerializedType]: ...
+def serialize(value: Any, get_type: Literal[False]) -> SerializedType | None: ...
 
 
 @overload
-def serialize(value: Any) -> Optional[SerializedType]: ...
+def serialize(value: Any) -> SerializedType | None: ...
 
 
 def serialize(
     value: Any, get_type: bool = False
 ) -> Union[
-    Optional[SerializedType],
-    Tuple[Optional[SerializedType], Optional[types.GenericType]],
+    SerializedType | None,
+    tuple[SerializedType | None, types.GenericType | None],
 ]:
     """Serialize the value to a JSON string.
 
@@ -164,7 +183,7 @@ def serialize(
 
 
 @functools.lru_cache
-def get_serializer(type_: Type) -> Optional[Serializer]:
+def get_serializer(type_: Type) -> Serializer | None:
     """Get the serializer for the type.
 
     Args:
@@ -188,7 +207,7 @@ def get_serializer(type_: Type) -> Optional[Serializer]:
 
 
 @functools.lru_cache
-def get_serializer_type(type_: Type) -> Optional[Type]:
+def get_serializer_type(type_: Type) -> Type | None:
     """Get the converted type for the type after serializing.
 
     Args:
@@ -315,6 +334,19 @@ def serialize_set(value: Set) -> list:
     return list(value)
 
 
+@serializer
+def serialize_sequence(value: Sequence) -> list:
+    """Serialize a sequence to a JSON serializable list.
+
+    Args:
+        value: The sequence to serialize.
+
+    Returns:
+        The serialized list.
+    """
+    return list(value)
+
+
 @serializer(to=str)
 def serialize_datetime(dt: Union[date, datetime, time, timedelta]) -> str:
     """Serialize a datetime to a JSON string.
@@ -354,6 +386,19 @@ def serialize_enum(en: Enum) -> str:
     return en.value
 
 
+@serializer(to=str)
+def serialize_uuid(uuid: UUID) -> str:
+    """Serialize a UUID to a JSON string.
+
+    Args:
+        uuid: The UUID to serialize.
+
+    Returns:
+        The serialized UUID.
+    """
+    return str(uuid)
+
+
 @serializer(to=str)
 def serialize_color(color: Color) -> str:
     """Serialize a color.
@@ -370,7 +415,7 @@ def serialize_color(color: Color) -> str:
 with contextlib.suppress(ImportError):
     from pandas import DataFrame
 
-    def format_dataframe_values(df: DataFrame) -> List[List[Any]]:
+    def format_dataframe_values(df: DataFrame) -> list[list[Any]]:
         """Format dataframe values to a list of lists.
 
         Args: