reflex 0.7.4a3__py3-none-any.whl → 0.7.5a1__py3-none-any.whl

reflex/utils/pyi_generator.py

@@ -55,6 +55,10 @@ EXCLUDED_PROPS = [
     "State",
 ]
 
+OVERWRITE_TYPES = {
+    "style": "Sequence[Mapping[str, Any]] | Mapping[str, Any] | Var[Mapping[str, Any]] | Breakpoints | None",
+}
+
 DEFAULT_TYPING_IMPORTS = {
     "overload",
     "Any",
@@ -62,6 +66,7 @@ DEFAULT_TYPING_IMPORTS = {
     "Dict",
     # "List",
     "Sequence",
+    "Mapping",
     "Literal",
     "Optional",
     "Union",
@@ -377,7 +382,9 @@ def _extract_class_props_as_ast_nodes(
                     ast.arg(
                         arg=name,
                         annotation=ast.Name(
-                            id=_get_type_hint(value, type_hint_globals)
+                            id=OVERWRITE_TYPES.get(
+                                name, _get_type_hint(value, type_hint_globals)
+                            )
                         ),
                     ),
                     ast.Constant(value=default),
@@ -386,7 +393,7 @@ def _extract_class_props_as_ast_nodes(
     return kwargs
 
 
-def type_to_ast(typ: Any, cls: type) -> ast.AST:
+def type_to_ast(typ: Any, cls: type) -> ast.expr:
     """Converts any type annotation into its AST representation.
     Handles nested generic types, unions, etc.
 
@@ -439,11 +446,11 @@ def type_to_ast(typ: Any, cls: type) -> ast.AST:
     if len(arg_nodes) == 1:
         slice_value = arg_nodes[0]
     else:
-        slice_value = ast.Tuple(elts=arg_nodes, ctx=ast.Load())  # pyright: ignore [reportArgumentType]
+        slice_value = ast.Tuple(elts=arg_nodes, ctx=ast.Load())
 
     return ast.Subscript(
         value=ast.Name(id=base_name),
-        slice=ast.Index(value=slice_value),  # pyright: ignore [reportArgumentType]
+        slice=slice_value,
         ctx=ast.Load(),
     )
 
@@ -463,16 +470,18 @@ def _get_parent_imports(func: Callable):
 
 
 def _generate_component_create_functiondef(
-    node: ast.FunctionDef | None,
-    clz: type[Component] | type[SimpleNamespace],
+    clz: type[Component],
     type_hint_globals: dict[str, Any],
+    lineno: int,
+    decorator_list: Sequence[ast.expr] = (ast.Name(id="classmethod"),),
 ) -> ast.FunctionDef:
     """Generate the create function definition for a Component.
 
     Args:
-        node: The existing create functiondef node from the ast
         clz: The Component class to generate the create functiondef for.
         type_hint_globals: The globals to use to resolving a type hint str.
+        lineno: The line number to use for the ast nodes.
+        decorator_list: The list of decorators to apply to the create functiondef.
 
     Returns:
         The create functiondef node for the ast.
@@ -584,28 +593,26 @@ def _generate_component_create_functiondef(
                 arg=trigger,
                 annotation=ast.Subscript(
                     ast.Name("Optional"),
-                    ast.Index(  # pyright: ignore [reportArgumentType]
-                        value=ast.Name(
-                            id=ast.unparse(
-                                figure_out_return_type(
-                                    inspect.signature(event_specs).return_annotation
-                                )
-                                if not isinstance(
-                                    event_specs := event_triggers[trigger], Sequence
-                                )
-                                else ast.Subscript(
-                                    ast.Name("Union"),
-                                    ast.Tuple(
-                                        [
-                                            figure_out_return_type(
-                                                inspect.signature(
-                                                    event_spec
-                                                ).return_annotation
-                                            )
-                                            for event_spec in event_specs
-                                        ]
-                                    ),
-                                )
+                    ast.Name(
+                        id=ast.unparse(
+                            figure_out_return_type(
+                                inspect.signature(event_specs).return_annotation
+                            )
+                            if not isinstance(
+                                event_specs := event_triggers[trigger], Sequence
+                            )
+                            else ast.Subscript(
+                                ast.Name("Union"),
+                                ast.Tuple(
+                                    [
+                                        figure_out_return_type(
+                                            inspect.signature(
+                                                event_spec
+                                            ).return_annotation
+                                        )
+                                        for event_spec in event_specs
+                                    ]
+                                ),
                             )
                         )
                     ),
@@ -630,7 +637,7 @@ def _generate_component_create_functiondef(
     definition = ast.FunctionDef(  # pyright: ignore [reportCallIssue]
         name="create",
         args=create_args,
-        body=[  # pyright: ignore [reportArgumentType]
+        body=[
             ast.Expr(
                 value=ast.Constant(
                     value=_generate_docstrings(
@@ -644,25 +651,19 @@ def _generate_component_create_functiondef(
         ],
         decorator_list=[
             ast.Name(id="overload"),
-            *(
-                node.decorator_list
-                if node is not None
-                else [ast.Name(id="classmethod")]
-            ),
+            *decorator_list,
         ],
-        lineno=node.lineno if node is not None else None,  # pyright: ignore [reportArgumentType]
+        lineno=lineno,
         returns=ast.Constant(value=clz.__name__),
     )
     return definition
 
 
 def _generate_staticmethod_call_functiondef(
-    node: ast.FunctionDef | None,
+    node: ast.ClassDef,
     clz: type[Component] | type[SimpleNamespace],
     type_hint_globals: dict[str, Any],
 ) -> ast.FunctionDef | None:
-    ...
-
     fullspec = getfullargspec(clz.__call__)
 
     call_args = ast.arguments(
@@ -699,7 +700,7 @@ def _generate_staticmethod_call_functiondef(
             ),
         ],
         decorator_list=[ast.Name(id="staticmethod")],
-        lineno=node.lineno if node is not None else None,  # pyright: ignore [reportArgumentType]
+        lineno=node.lineno,
         returns=ast.Constant(
             value=_get_type_hint(
                 typing.get_type_hints(clz.__call__).get("return", None),
@@ -712,7 +713,7 @@ def _generate_staticmethod_call_functiondef(
 
 
 def _generate_namespace_call_functiondef(
-    node: ast.ClassDef | None,
+    node: ast.ClassDef,
     clz_name: str,
     classes: dict[str, type[Component] | type[SimpleNamespace]],
     type_hint_globals: dict[str, Any],
@@ -736,7 +737,7 @@ def _generate_namespace_call_functiondef(
     clz = classes[clz_name]
 
     if not hasattr(clz.__call__, "__self__"):
-        return _generate_staticmethod_call_functiondef(node, clz, type_hint_globals)  # pyright: ignore [reportArgumentType]
+        return _generate_staticmethod_call_functiondef(node, clz, type_hint_globals)
 
     # Determine which class is wrapped by the namespace __call__ method
     component_clz = clz.__call__.__self__
@@ -744,10 +745,14 @@ def _generate_namespace_call_functiondef(
     if clz.__call__.__func__.__name__ != "create":  # pyright: ignore [reportFunctionMemberAccess]
         return None
 
+    if not issubclass(component_clz, Component):
+        return None
+
     definition = _generate_component_create_functiondef(
-        node=None,
-        clz=component_clz,  # pyright: ignore [reportArgumentType]
+        clz=component_clz,
         type_hint_globals=type_hint_globals,
+        lineno=node.lineno,
+        decorator_list=[],
     )
     definition.name = "__call__"
 
@@ -804,17 +809,18 @@ class StubGenerator(ast.NodeTransformer):
             node.body.pop(0)
         return node
 
-    def _current_class_is_component(self) -> bool:
+    def _current_class_is_component(self) -> type[Component] | None:
         """Check if the current class is a Component.
 
         Returns:
             Whether the current class is a Component.
         """
-        return (
+        if (
             self.current_class is not None
             and self.current_class in self.classes
-            and issubclass(self.classes[self.current_class], Component)
-        )
+            and issubclass((clz := self.classes[self.current_class]), Component)
+        ):
+            return clz
 
     def visit_Module(self, node: ast.Module) -> ast.Module:
         """Visit a Module node and remove docstring from body.
@@ -916,14 +922,14 @@ class StubGenerator(ast.NodeTransformer):
                 isinstance(child, ast.FunctionDef) and child.name == "create"
                 for child in node.body
             )
-            and self._current_class_is_component()
+            and (clz := self._current_class_is_component()) is not None
         ):
             # Add a new .create FunctionDef since one does not exist.
             node.body.append(
                 _generate_component_create_functiondef(
-                    node=None,
-                    clz=self.classes[self.current_class],
+                    clz=clz,
                     type_hint_globals=self.type_hint_globals,
+                    lineno=node.lineno,
                 )
             )
         if call_definition is not None:
@@ -949,9 +955,16 @@ class StubGenerator(ast.NodeTransformer):
         Returns:
             The modified FunctionDef node (or None).
         """
-        if node.name == "create" and self.current_class in self.classes:
+        if (
+            node.name == "create"
+            and self.current_class in self.classes
+            and issubclass((clz := self.classes[self.current_class]), Component)
+        ):
             node = _generate_component_create_functiondef(
-                node, self.classes[self.current_class], self.type_hint_globals
+                clz=clz,
+                type_hint_globals=self.type_hint_globals,
+                lineno=node.lineno,
+                decorator_list=node.decorator_list,
             )
         else:
             if node.name.startswith("_") and node.name != "__call__":

reflex/utils/registry.py

@@ -4,6 +4,7 @@ import httpx
 
 from reflex.config import environment
 from reflex.utils import console, net
+from reflex.utils.decorator import once
 
 
 def latency(registry: str) -> int:
@@ -48,15 +49,16 @@ def _get_best_registry() -> str:
     """
     console.debug("Getting best registry...")
     registries = [
-        "https://registry.npmjs.org",
-        "https://r.cnpmjs.org",
+        ("https://registry.npmjs.org", 1),
+        ("https://registry.npmmirror.com", 2),
     ]
 
-    best_registry = min(registries, key=average_latency)
+    best_registry = min(registries, key=lambda x: average_latency(x[0]) * x[1])[0]
     console.debug(f"Best registry: {best_registry}")
     return best_registry
 
 
+@once
 def get_npm_registry() -> str:
     """Get npm registry. If environment variable is set, use it first.
 

reflex/utils/serializers.py

@@ -16,7 +16,6 @@ from typing import (
     Callable,
     Literal,
     Sequence,
-    Set,
     Type,
     TypeVar,
     Union,
@@ -322,7 +321,7 @@ if BaseModelV1 is not BaseModelV2:
 
 
 @serializer
-def serialize_set(value: Set) -> list:
+def serialize_set(value: set) -> list:
     """Serialize a set to a JSON serializable list.
 
     Args:

reflex/utils/types.py

@@ -140,7 +140,7 @@ def is_generic_alias(cls: GenericType) -> bool:
     Returns:
         Whether the class is a generic alias.
     """
-    return isinstance(cls, GenericAliasTypes)  # pyright: ignore [reportArgumentType]
+    return isinstance(cls, GenericAliasTypes)
 
 
 @lru_cache()
@@ -923,7 +923,7 @@ StateBases = get_base_class(StateVar)
 StateIterBases = get_base_class(StateIterVar)
 
 
-def safe_issubclass(cls: Type, cls_check: Type | tuple[Type, ...]):
+def safe_issubclass(cls: Any, cls_check: Any | tuple[Any, ...]):
     """Check if a class is a subclass of another class. Returns False if internal error occurs.
 
     Args:
@@ -1047,8 +1047,8 @@ def typehint_issubclass(
 
     # Check if the origin of both types is the same (e.g., list for list[int])
     if not safe_issubclass(
-        provided_type_origin or possible_subclass,  # pyright: ignore [reportArgumentType]
-        accepted_type_origin or possible_superclass,  # pyright: ignore [reportArgumentType]
+        provided_type_origin or possible_subclass,
+        accepted_type_origin or possible_superclass,
     ):
         return False
 

reflex/vars/base.py

@@ -30,6 +30,7 @@ from typing import (
     Mapping,
     NoReturn,
     ParamSpec,
+    Protocol,
     Sequence,
     Set,
     Tuple,
@@ -59,10 +60,11 @@ from reflex.utils.exceptions import (
 )
 from reflex.utils.format import format_state_name
 from reflex.utils.imports import (
+    ImmutableImportDict,
     ImmutableParsedImportDict,
     ImportDict,
     ImportVar,
-    ParsedImportDict,
+    ParsedImportTuple,
     parse_imports,
 )
 from reflex.utils.types import (
@@ -122,7 +124,7 @@ class VarData:
     field_name: str = dataclasses.field(default="")
 
     # Imports needed to render this var
-    imports: ImmutableParsedImportDict = dataclasses.field(default_factory=tuple)
+    imports: ParsedImportTuple = dataclasses.field(default_factory=tuple)
 
     # Hooks that need to be present in the component to render this var
     hooks: tuple[str, ...] = dataclasses.field(default_factory=tuple)
@@ -140,7 +142,7 @@ class VarData:
         self,
         state: str = "",
         field_name: str = "",
-        imports: ImportDict | ParsedImportDict | None = None,
+        imports: ImmutableImportDict | ImmutableParsedImportDict | None = None,
         hooks: Mapping[str, VarData | None] | Sequence[str] | str | None = None,
         deps: list[Var] | None = None,
         position: Hooks.HookPosition | None = None,
@@ -161,7 +163,7 @@ class VarData:
             hooks = [hooks]
         if not isinstance(hooks, dict):
             hooks = dict.fromkeys(hooks or [])
-        immutable_imports: ImmutableParsedImportDict = tuple(
+        immutable_imports: ParsedImportTuple = tuple(
             (k, tuple(v)) for k, v in parse_imports(imports or {}).items()
         )
         object.__setattr__(self, "state", state)
@@ -988,7 +990,7 @@ class Var(Generic[VAR_TYPE]):
                     setattr(state, actual_name, value)
                 except ValueError:
                     console.debug(
-                        f"{type(state).__name__}.{self._js_expr}: Failed conversion of {value} to '{self._var_type.__name__}'. Value not set.",
+                        f"{type(state).__name__}.{self._js_expr}: Failed conversion of {value!s} to '{self._var_type.__name__}'. Value not set.",
                     )
             else:
                 setattr(state, actual_name, value)
@@ -1058,7 +1060,9 @@ class Var(Generic[VAR_TYPE]):
 
         return boolify(self)
 
-    def __and__(self, other: Var | Any) -> Var:
+    def __and__(
+        self, other: Var[OTHER_VAR_TYPE] | Any
+    ) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
         """Perform a logical AND operation on the current instance and another variable.
 
         Args:
@@ -1069,7 +1073,9 @@ class Var(Generic[VAR_TYPE]):
         """
         return and_operation(self, other)
 
-    def __rand__(self, other: Var | Any) -> Var:
+    def __rand__(
+        self, other: Var[OTHER_VAR_TYPE] | Any
+    ) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
         """Perform a logical AND operation on the current instance and another variable.
 
         Args:
@@ -1080,7 +1086,9 @@ class Var(Generic[VAR_TYPE]):
         """
         return and_operation(other, self)
 
-    def __or__(self, other: Var | Any) -> Var:
+    def __or__(
+        self, other: Var[OTHER_VAR_TYPE] | Any
+    ) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
         """Perform a logical OR operation on the current instance and another variable.
 
         Args:
@@ -1091,7 +1099,9 @@ class Var(Generic[VAR_TYPE]):
         """
         return or_operation(self, other)
 
-    def __ror__(self, other: Var | Any) -> Var:
+    def __ror__(
+        self, other: Var[OTHER_VAR_TYPE] | Any
+    ) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
         """Perform a logical OR operation on the current instance and another variable.
 
         Args:
@@ -1478,7 +1488,7 @@ class LiteralVar(Var):
         _var_literal_subclasses.append((cls, var_subclass))
 
     @classmethod
-    def create(  # pyright: ignore [reportArgumentType]
+    def _create_literal_var(
         cls,
         value: Any,
         _var_data: VarData | None = None,
@@ -1559,6 +1569,9 @@ class LiteralVar(Var):
             f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
         )
 
+    if not TYPE_CHECKING:
+        create = _create_literal_var
+
     def __post_init__(self):
         """Post-initialize the var."""
 
@@ -1835,6 +1848,21 @@ class cached_property:  # noqa: N801
 cached_property_no_lock = cached_property
 
 
+class VarProtocol(Protocol):
+    """A protocol for Var."""
+
+    __dataclass_fields__: ClassVar[dict[str, dataclasses.Field[Any]]]
+
+    @property
+    def _js_expr(self) -> str: ...
+
+    @property
+    def _var_type(self) -> types.GenericType: ...
+
+    @property
+    def _var_data(self) -> VarData: ...
+
+
 class CachedVarOperation:
     """Base class for cached var operations to lower boilerplate code."""
 
@@ -1869,7 +1897,7 @@ class CachedVarOperation:
         return self._cached_get_all_var_data
 
     @cached_property_no_lock
-    def _cached_get_all_var_data(self) -> VarData | None:
+    def _cached_get_all_var_data(self: VarProtocol) -> VarData | None:
         """Get the cached VarData.
 
         Returns:
@@ -1879,14 +1907,13 @@ class CachedVarOperation:
             *(
                 value._get_all_var_data() if isinstance(value, Var) else None
                 for value in (
-                    getattr(self, field.name)
-                    for field in dataclasses.fields(self)  # pyright: ignore [reportArgumentType]
+                    getattr(self, field.name) for field in dataclasses.fields(self)
                 )
             ),
             self._var_data,
         )
 
-    def __hash__(self) -> int:
+    def __hash__(self: DataclassInstance) -> int:
         """Calculate the hash of the object.
 
         Returns:
@@ -1897,14 +1924,16 @@ class CachedVarOperation:
                 type(self).__name__,
                 *[
                     getattr(self, field.name)
-                    for field in dataclasses.fields(self)  # pyright: ignore [reportArgumentType]
+                    for field in dataclasses.fields(self)
                     if field.name not in ["_js_expr", "_var_data", "_var_type"]
                 ],
             )
         )
 
 
-def and_operation(a: Var | Any, b: Var | Any) -> Var:
+def and_operation(
+    a: Var[VAR_TYPE] | Any, b: Var[OTHER_VAR_TYPE] | Any
+) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
     """Perform a logical AND operation on two variables.
 
     Args:
@@ -1934,7 +1963,9 @@ def _and_operation(a: Var, b: Var):
     )
 
 
-def or_operation(a: Var | Any, b: Var | Any) -> Var:
+def or_operation(
+    a: Var[VAR_TYPE] | Any, b: Var[OTHER_VAR_TYPE] | Any
+) -> Var[VAR_TYPE | OTHER_VAR_TYPE]:
     """Perform a logical OR operation on two variables.
 
     Args:
@@ -2340,7 +2371,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         if not _isinstance(value, self._var_type, nested=1, treat_var_as_type=False):
             console.error(
                 f"Computed var '{type(instance).__name__}.{self._js_expr}' must return"
-                f" a value of type '{self._var_type}', got '{value}' of type {type(value)}."
+                f" a value of type '{self._var_type}', got '{value!s}' of type {type(value)}."
             )
 
     def _deps(
@@ -2976,7 +3007,7 @@ def get_uuid_string_var() -> Var:
     unique_uuid_var = get_unique_variable_name()
     unique_uuid_var_data = VarData(
         imports={
-            f"$/{constants.Dirs.STATE_PATH}": {ImportVar(tag="generateUUID")},  # pyright: ignore [reportArgumentType]
+            f"$/{constants.Dirs.STATE_PATH}": ImportVar(tag="generateUUID"),
             "react": "useMemo",
         },
         hooks={f"const {unique_uuid_var} = useMemo(generateUUID, [])": None},
@@ -3286,10 +3317,15 @@ class Field(Generic[FIELD_TYPE]):
 
     @overload
     def __get__(
-        self: Field[int]
-        | Field[float]
+        self: Field[int] | Field[int | None],
+        instance: None,
+        owner: Any,
+    ) -> NumberVar[int]: ...
+
+    @overload
+    def __get__(
+        self: Field[float]
         | Field[int | float]
-        | Field[int | None]
         | Field[float | None]
         | Field[int | float | None],
         instance: None,

reflex/vars/number.py

@@ -16,6 +16,8 @@ from typing import (
     overload,
 )
 
+from typing_extensions import TypeVar as TypeVarExt
+
 from reflex.constants.base import Dirs
 from reflex.utils.exceptions import (
     PrimitiveUnserializableToJSONError,
@@ -35,7 +37,9 @@ from .base import (
     var_operation_return,
 )
 
-NUMBER_T = TypeVar("NUMBER_T", int, float, bool)
+NUMBER_T = TypeVarExt(
+    "NUMBER_T", bound=(int | float), default=(int | float), covariant=True
+)
 
 if TYPE_CHECKING:
     from .sequence import ArrayVar
@@ -313,13 +317,19 @@ class NumberVar(Var[NUMBER_T], python_types=(int, float)):
         """
         return self
 
-    def __round__(self):
+    def __round__(self, ndigits: int | NumberVar = 0) -> NumberVar:
         """Round the number.
 
+        Args:
+            ndigits: The number of digits to round.
+
         Returns:
             The number round operation.
         """
-        return number_round_operation(self)
+        if not isinstance(ndigits, NUMBER_TYPES):
+            raise_unsupported_operand_types("round", (type(self), type(ndigits)))
+
+        return number_round_operation(self, +ndigits)
 
     def __ceil__(self):
         """Ceil the number.
@@ -653,16 +663,23 @@ def number_exponent_operation(lhs: NumberVar, rhs: NumberVar):
 
 
 @var_operation
-def number_round_operation(value: NumberVar):
+def number_round_operation(value: NumberVar, ndigits: NumberVar | int):
     """Round the number.
 
     Args:
         value: The number.
+        ndigits: The number of digits.
 
     Returns:
         The number round operation.
     """
-    return var_operation_return(js_expression=f"Math.round({value})", var_type=int)
+    if (isinstance(ndigits, LiteralNumberVar) and ndigits._var_value == 0) or (
+        isinstance(ndigits, int) and ndigits == 0
+    ):
+        return var_operation_return(js_expression=f"Math.round({value})", var_type=int)
+    return var_operation_return(
+        js_expression=f"(+{value}.toFixed({ndigits}))", var_type=float
+    )
 
 
 @var_operation
@@ -1064,7 +1081,7 @@ U = TypeVar("U")
 
 @var_operation
 def ternary_operation(
-    condition: BooleanVar, if_true: Var[T], if_false: Var[U]
+    condition: Var[bool], if_true: Var[T], if_false: Var[U]
 ) -> CustomVarOperationReturn[T | U]:
     """Create a ternary operation.
 

reflex/vars/sequence.py

@@ -1604,6 +1604,8 @@ def _determine_value_of_array_index(
         return args[0] if args else Any
     if origin_var_type is tuple:
         args = get_args(var_type)
+        if len(args) == 2 and args[1] is ...:
+            return args[0]
         return (
             args[int(index) % len(args)]
             if args and index is not None

{reflex-0.7.4a3.dist-info → reflex-0.7.5a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.7.4a3
+Version: 0.7.5a1
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -23,7 +23,7 @@ Requires-Dist: build<2.0,>=1.0.3
 Requires-Dist: charset-normalizer<4.0,>=3.3.2
 Requires-Dist: distro<2.0,>=1.8.0; platform_system == 'Linux'
 Requires-Dist: fastapi!=0.111.0,!=0.111.1,>=0.96.0
-Requires-Dist: granian[reload]>=2.0.0
+Requires-Dist: granian[reload]>=2.2.0
 Requires-Dist: gunicorn<24.0.0,>=23.0.0
 Requires-Dist: httpx<1.0,>=0.25.1
 Requires-Dist: jinja2<4.0,>=3.1.2