reflex 0.5.5a1__py3-none-any.whl → 0.5.6__py3-none-any.whl

reflex/utils/pyi_generator.py

@@ -9,20 +9,15 @@ import inspect
 import logging
 import re
 import subprocess
-import textwrap
 import typing
+from fileinput import FileInput
 from inspect import getfullargspec
+from itertools import chain
 from multiprocessing import Pool, cpu_count
 from pathlib import Path
 from types import ModuleType, SimpleNamespace
 from typing import Any, Callable, Iterable, Type, get_args
 
-try:
-    import black
-    import black.mode
-except ImportError:
-    black = None
-
 from reflex.components.component import Component
 from reflex.utils import types as rx_types
 from reflex.vars import Var
@@ -63,6 +58,7 @@ EXCLUDED_PROPS = [
 DEFAULT_TYPING_IMPORTS = {
     "overload",
     "Any",
+    "Callable",
     "Dict",
     # "List",
     "Literal",
@@ -70,6 +66,15 @@ DEFAULT_TYPING_IMPORTS = {
     "Union",
 }
 
+# TODO: fix import ordering and unused imports with ruff later
+DEFAULT_IMPORTS = {
+    "typing": sorted(DEFAULT_TYPING_IMPORTS),
+    "reflex.vars": ["Var", "BaseVar", "ComputedVar"],
+    "reflex.components.core.breakpoints": ["Breakpoints"],
+    "reflex.event": ["EventChain", "EventHandler", "EventSpec"],
+    "reflex.style": ["Style"],
+}
+
 
 def _walk_files(path):
     """Walk all files in a path.
@@ -112,6 +117,9 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
 
     Returns:
         The resolved type hint as a str.
+
+    Raises:
+        TypeError: If the value name is not visible in the type hint globals.
     """
     res = ""
     args = get_args(value)
@@ -126,6 +134,7 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
                 for arg in value.__args__
                 if arg is not type(None)
             ]
+            res_args.sort()
             if len(res_args) == 1:
                 return f"Optional[{res_args[0]}]"
             else:
@@ -136,6 +145,7 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
             _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)}]"
 
     if args:
@@ -148,9 +158,22 @@ def _get_type_hint(value, type_hint_globals, is_optional=True) -> str:
                 if arg is not type(None)
             ]
         )
+
+        if value.__name__ not in type_hint_globals:
+            raise TypeError(
+                f"{value.__module__ + '.' + value.__name__} is not a default import, "
+                "add it to DEFAULT_IMPORTS in pyi_generator.py"
+            )
+
         res = f"{value.__name__}[{', '.join(inner_container_type_args)}]"
 
         if value.__name__ == "Var":
+            args = list(
+                chain.from_iterable(
+                    [get_args(arg) if rx_types.is_union(arg) else [arg] for arg in args]
+                )
+            )
+
             # For Var types, Union with the inner args so they can be passed directly.
             types = [res] + [
                 _get_type_hint(arg, type_hint_globals, is_optional=False)
@@ -198,22 +221,10 @@ def _generate_imports(typing_imports: Iterable[str]) -> list[ast.ImportFrom]:
         The list of import statements.
     """
     return [
-        ast.ImportFrom(
-            module="typing",
-            names=[ast.alias(name=imp) for imp in sorted(typing_imports)],
-        ),
-        *ast.parse(  # type: ignore
-            textwrap.dedent(
-                """
-                from reflex.vars import Var, BaseVar, ComputedVar
-                from reflex.event import EventChain, EventHandler, EventSpec
-                from reflex.style import Style"""
-            )
-        ).body,
-        # *[
-        #     ast.ImportFrom(module=name, names=[ast.alias(name=val) for val in values])
-        #     for name, values in EXTRA_IMPORTS.items()
-        # ],
+        *[
+            ast.ImportFrom(module=name, names=[ast.alias(name=val) for val in values])
+            for name, values in DEFAULT_IMPORTS.items()
+        ],
     ]
 
 
@@ -419,7 +430,7 @@ def _generate_component_create_functiondef(
             ast.arg(
                 arg=trigger,
                 annotation=ast.Name(
-                    id="Optional[Union[EventHandler, EventSpec, list, function, BaseVar]]"
+                    id="Optional[Union[EventHandler, EventSpec, list, Callable, BaseVar]]"
                 ),
             ),
             ast.Constant(value=None),
@@ -488,9 +499,11 @@ def _generate_staticmethod_call_functiondef(
         kwonlyargs=[],
         kw_defaults=[],
         kwarg=ast.arg(arg="props"),
-        defaults=[ast.Constant(value=default) for default in fullspec.defaults]
-        if fullspec.defaults
-        else [],
+        defaults=(
+            [ast.Constant(value=default) for default in fullspec.defaults]
+            if fullspec.defaults
+            else []
+        ),
     )
     definition = ast.FunctionDef(
         name="__call__",
@@ -578,7 +591,7 @@ class StubGenerator(ast.NodeTransformer):
         # Track the last class node that was visited.
         self.current_class = None
         # These imports will be included in the AST of stub files.
-        self.typing_imports = DEFAULT_TYPING_IMPORTS
+        self.typing_imports = DEFAULT_TYPING_IMPORTS.copy()
         # Whether those typing imports have been inserted yet.
         self.inserted_imports = False
         # Collected import statements from the module.
@@ -646,7 +659,9 @@ class StubGenerator(ast.NodeTransformer):
         self.import_statements.append(ast.unparse(node))
         if not self.inserted_imports:
             self.inserted_imports = True
-            return _generate_imports(self.typing_imports) + [node]
+            default_imports = _generate_imports(self.typing_imports)
+            self.import_statements.extend(ast.unparse(i) for i in default_imports)
+            return default_imports + [node]
         return node
 
     def visit_ImportFrom(
@@ -839,37 +854,25 @@ class PyiGenerator:
     modules: list = []
     root: str = ""
     current_module: Any = {}
+    written_files: list[str] = []
 
     def _write_pyi_file(self, module_path: Path, source: str):
         relpath = str(_relative_to_pwd(module_path)).replace("\\", "/")
-        pyi_content = [
-            f'"""Stub file for {relpath}"""',
-            "# ------------------- DO NOT EDIT ----------------------",
-            "# This file was generated by `reflex/utils/pyi_generator.py`!",
-            "# ------------------------------------------------------",
-            "",
-        ]
-        if black is not None:
-            for formatted_line in black.format_file_contents(
-                src_contents=source,
-                fast=True,
-                mode=black.mode.Mode(is_pyi=True),
-            ).splitlines():
-                # Bit of a hack here, since the AST cannot represent comments.
-                if (
-                    "def create(" in formatted_line
-                    or "Figure" in formatted_line
-                    or "Var[Template]" in formatted_line
-                ):
-                    pyi_content.append(formatted_line + "  # type: ignore")
-                else:
-                    pyi_content.append(formatted_line)
-            pyi_content.append("")  # add empty line at the end for formatting
-        else:
-            pyi_content = source.splitlines()
+        pyi_content = (
+            "\n".join(
+                [
+                    f'"""Stub file for {relpath}"""',
+                    "# ------------------- DO NOT EDIT ----------------------",
+                    "# This file was generated by `reflex/utils/pyi_generator.py`!",
+                    "# ------------------------------------------------------",
+                    "",
+                ]
+            )
+            + source
+        )
 
         pyi_path = module_path.with_suffix(".pyi")
-        pyi_path.write_text("\n".join(pyi_content))
+        pyi_path.write_text(pyi_content)
         logger.info(f"Wrote {relpath}")
 
     def _get_init_lazy_imports(self, mod, new_tree):
@@ -903,7 +906,7 @@ class PyiGenerator:
         text += ast.unparse(new_tree) + "\n"
         return text
 
-    def _scan_file(self, module_path: Path):
+    def _scan_file(self, module_path: Path) -> str | None:
         module_import = (
             _relative_to_pwd(module_path)
             .with_suffix("")
@@ -930,21 +933,25 @@ class PyiGenerator:
                 ast.parse(inspect.getsource(module))
             )
             init_imports = self._get_init_lazy_imports(module, new_tree)
-            if init_imports:
-                self._write_pyi_file(module_path, init_imports)
+            if not init_imports:
+                return
+            self._write_pyi_file(module_path, init_imports)
         else:
             new_tree = StubGenerator(module, class_names).visit(
                 ast.parse(inspect.getsource(module))
             )
             self._write_pyi_file(module_path, ast.unparse(new_tree))
+        return str(module_path.with_suffix(".pyi").resolve())
 
     def _scan_files_multiprocess(self, files: list[Path]):
         with Pool(processes=cpu_count()) as pool:
-            pool.map(self._scan_file, files)
+            self.written_files.extend(f for f in pool.map(self._scan_file, files) if f)
 
     def _scan_files(self, files: list[Path]):
         for file in files:
-            self._scan_file(file)
+            pyi_path = self._scan_file(file)
+            if pyi_path:
+                self.written_files.append(pyi_path)
 
     def scan_all(self, targets, changed_files: list[Path] | None = None):
         """Scan all targets for class inheriting Component and generate the .pyi files.
@@ -960,7 +967,6 @@ class PyiGenerator:
                 target_path.is_file()
                 and target_path.suffix == ".py"
                 and target_path.name not in EXCLUDED_FILES
-                and "reflex/components" in str(target_path)
             ):
                 file_targets.append(target_path)
                 continue
@@ -993,3 +999,24 @@ class PyiGenerator:
             self._scan_files(file_targets)
         else:
             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])
+
+        # 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]
+        subprocess.run(["ruff", "format", *init_files])
+
+        # Post-process the generated pyi files to add hacky type: ignore comments
+        for file_path in self.written_files:
+            with FileInput(file_path, inplace=True) as f:
+                for line in f:
+                    # Hack due to ast not supporting comments in the tree.
+                    if (
+                        "def create(" in line
+                        or "Var[Figure]" in line
+                        or "Var[Template]" in line
+                    ):
+                        line = line.rstrip() + "  # type: ignore\n"
+                    print(line, end="")

reflex/utils/types.py

@@ -6,10 +6,11 @@ import contextlib
 import inspect
 import sys
 import types
-from functools import wraps
+from functools import cached_property, wraps
 from typing import (
     Any,
     Callable,
+    ClassVar,
     Dict,
     Iterable,
     List,
@@ -26,6 +27,9 @@ from typing import (
 
 import sqlalchemy
 
+import reflex
+from reflex.components.core.breakpoints import Breakpoints
+
 try:
     from pydantic.v1.fields import ModelField
 except ModuleNotFoundError:
@@ -99,6 +103,12 @@ PrimitiveToAnnotation = {
     dict: Dict,
 }
 
+RESERVED_BACKEND_VAR_NAMES = {
+    "_abc_impl",
+    "_backend_vars",
+    "_was_touched",
+}
+
 
 class Unset:
     """A class to represent an unset value.
@@ -324,12 +334,44 @@ def get_base_class(cls: GenericType) -> Type:
     return get_base_class(cls.__origin__) if is_generic_alias(cls) else cls
 
 
-def _issubclass(cls: GenericType, cls_check: GenericType) -> bool:
+def _breakpoints_satisfies_typing(cls_check: GenericType, instance: Any) -> bool:
+    """Check if the breakpoints instance satisfies the typing.
+
+    Args:
+        cls_check: The class to check against.
+        instance: The instance to check.
+
+    Returns:
+        Whether the breakpoints instance satisfies the typing.
+    """
+    cls_check_base = get_base_class(cls_check)
+
+    if cls_check_base == Breakpoints:
+        _, expected_type = get_args(cls_check)
+        if is_literal(expected_type):
+            for value in instance.values():
+                if not isinstance(value, str) or value not in get_args(expected_type):
+                    return False
+        return True
+    elif isinstance(cls_check_base, tuple):
+        # union type, so check all types
+        return any(
+            _breakpoints_satisfies_typing(type_to_check, instance)
+            for type_to_check in get_args(cls_check)
+        )
+    elif cls_check_base == reflex.vars.Var and "__args__" in cls_check.__dict__:
+        return _breakpoints_satisfies_typing(get_args(cls_check)[0], instance)
+
+    return False
+
+
+def _issubclass(cls: GenericType, cls_check: GenericType, instance: Any = None) -> bool:
     """Check if a class is a subclass of another class.
 
     Args:
         cls: The class to check.
         cls_check: The class to check against.
+        instance: An instance of cls to aid in checking generics.
 
     Returns:
         Whether the class is a subclass of the other class.
@@ -351,6 +393,10 @@ def _issubclass(cls: GenericType, cls_check: GenericType) -> bool:
     if isinstance(cls_base, tuple):
         return False
 
+    # Check that fields of breakpoints match the expected values.
+    if isinstance(instance, Breakpoints):
+        return _breakpoints_satisfies_typing(cls_check, instance)
+
     # Check if the types match.
     try:
         return cls_check_base == Any or issubclass(cls_base, cls_check_base)
@@ -403,7 +449,7 @@ def is_valid_var_type(type_: Type) -> bool:
     return _issubclass(type_, StateVar) or serializers.has_serializer(type_)
 
 
-def is_backend_variable(name: str, cls: Type | None = None) -> bool:
+def is_backend_base_variable(name: str, cls: Type) -> bool:
     """Check if this variable name correspond to a backend variable.
 
     Args:
@@ -413,9 +459,41 @@ def is_backend_variable(name: str, cls: Type | None = None) -> bool:
     Returns:
         bool: The result of the check
     """
-    if cls is not None and name.startswith(f"_{cls.__name__}__"):
+    if name in RESERVED_BACKEND_VAR_NAMES:
+        return False
+
+    if not name.startswith("_"):
+        return False
+
+    if name.startswith("__"):
+        return False
+
+    if name.startswith(f"_{cls.__name__}__"):
+        return False
+
+    hints = get_type_hints(cls)
+    if name in hints:
+        hint = get_origin(hints[name])
+        if hint == ClassVar:
+            return False
+
+    if name in cls.inherited_backend_vars:
         return False
-    return name.startswith("_") and not name.startswith("__")
+
+    if name in cls.__dict__:
+        value = cls.__dict__[name]
+        if type(value) == classmethod:
+            return False
+        if callable(value):
+            return False
+        from reflex.vars import ComputedVar
+
+        if isinstance(
+            value, (types.FunctionType, property, cached_property, ComputedVar)
+        ):
+            return False
+
+    return True
 
 
 def check_type_in_allowed_types(value_type: Type, allowed_types: Iterable) -> bool:

reflex/vars.py

@@ -36,7 +36,12 @@ from typing import (
 from reflex import constants
 from reflex.base import Base
 from reflex.utils import console, imports, serializers, types
-from reflex.utils.exceptions import VarAttributeError, VarTypeError, VarValueError
+from reflex.utils.exceptions import (
+    VarAttributeError,
+    VarDependencyError,
+    VarTypeError,
+    VarValueError,
+)
 
 # This module used to export ImportVar itself, so we still import it for export here
 from reflex.utils.imports import (
@@ -416,7 +421,7 @@ class Var:
 
         if _var_is_string is None and type_ is str:
             console.deprecate(
-                feature_name="Creating a Var from a string without specifying _var_is_string",
+                feature_name=f"Creating a Var ({value}) from a string without specifying _var_is_string",
                 reason=(
                     "Specify _var_is_string=False to create a Var that is not a string literal. "
                     "In the future, creating a Var from a string will be treated as a string literal "
@@ -1939,6 +1944,9 @@ class ComputedVar(Var, property):
     # Whether to track dependencies and cache computed values
     _cache: bool = dataclasses.field(default=False)
 
+    # Whether the computed var is a backend var
+    _backend: bool = dataclasses.field(default=False)
+
     # The initial value of the computed var
     _initial_value: Any | types.Unset = dataclasses.field(default=types.Unset())
 
@@ -1959,6 +1967,7 @@ class ComputedVar(Var, property):
         deps: Optional[List[Union[str, Var]]] = None,
         auto_deps: bool = True,
         interval: Optional[Union[int, datetime.timedelta]] = None,
+        backend: bool | None = None,
         **kwargs,
     ):
         """Initialize a ComputedVar.
@@ -1970,8 +1979,16 @@ class ComputedVar(Var, property):
             deps: Explicit var dependencies to track.
             auto_deps: Whether var dependencies should be auto-determined.
             interval: Interval at which the computed var should be updated.
+            backend: Whether the computed var is a backend var.
             **kwargs: additional attributes to set on the instance
+
+        Raises:
+            TypeError: If the computed var dependencies are not Var instances or var names.
         """
+        if backend is None:
+            backend = fget.__name__.startswith("_")
+        self._backend = backend
+
         self._initial_value = initial_value
         self._cache = cache
         if isinstance(interval, int):
@@ -1979,6 +1996,15 @@ class ComputedVar(Var, property):
         self._update_interval = interval
         if deps is None:
             deps = []
+        else:
+            for dep in deps:
+                if isinstance(dep, Var):
+                    continue
+                if isinstance(dep, str) and dep != "":
+                    continue
+                raise TypeError(
+                    "ComputedVar dependencies must be Var instances or var names (non-empty strings)."
+                )
         self._static_deps = {
             dep._var_name if isinstance(dep, Var) else dep for dep in deps
         }
@@ -2006,6 +2032,7 @@ class ComputedVar(Var, property):
             deps=kwargs.get("deps", self._static_deps),
             auto_deps=kwargs.get("auto_deps", self._auto_deps),
             interval=kwargs.get("interval", self._update_interval),
+            backend=kwargs.get("backend", self._backend),
             _var_name=kwargs.get("_var_name", self._var_name),
             _var_type=kwargs.get("_var_type", self._var_type),
             _var_is_local=kwargs.get("_var_is_local", self._var_is_local),
@@ -2157,8 +2184,21 @@ class ComputedVar(Var, property):
                             obj=ref_obj,
                         )
                     )
-                else:
-                    # normal attribute access
+                # recurse into property fget functions
+                elif isinstance(ref_obj, property) and not isinstance(
+                    ref_obj, ComputedVar
+                ):
+                    d.update(
+                        self._deps(
+                            objclass=objclass,
+                            obj=ref_obj.fget,  # type: ignore
+                        )
+                    )
+                elif (
+                    instruction.argval in objclass.backend_vars
+                    or instruction.argval in objclass.vars
+                ):
+                    # var access
                     d.add(instruction.argval)
             elif instruction.opname == "LOAD_CONST" and isinstance(
                 instruction.argval, CodeType
@@ -2203,6 +2243,8 @@ def computed_var(
     deps: Optional[List[Union[str, Var]]] = None,
     auto_deps: bool = True,
     interval: Optional[Union[datetime.timedelta, int]] = None,
+    backend: bool | None = None,
+    _deprecated_cached_var: bool = False,
     **kwargs,
 ) -> ComputedVar | Callable[[Callable[[BaseState], Any]], ComputedVar]:
     """A ComputedVar decorator with or without kwargs.
@@ -2214,6 +2256,8 @@ def computed_var(
         deps: Explicit var dependencies to track.
         auto_deps: Whether var dependencies should be auto-determined.
         interval: Interval at which the computed var should be updated.
+        backend: Whether the computed var is a backend var.
+        _deprecated_cached_var: Indicate usage of deprecated cached_var partial function.
         **kwargs: additional attributes to set on the instance
 
     Returns:
@@ -2221,10 +2265,22 @@ def computed_var(
 
     Raises:
         ValueError: If caching is disabled and an update interval is set.
+        VarDependencyError: If user supplies dependencies without caching.
     """
+    if _deprecated_cached_var:
+        console.deprecate(
+            feature_name="cached_var",
+            reason=("Use @rx.var(cache=True) instead of @rx.cached_var."),
+            deprecation_version="0.5.6",
+            removal_version="0.6.0",
+        )
+
     if cache is False and interval is not None:
         raise ValueError("Cannot set update interval without caching.")
 
+    if cache is False and (deps is not None or auto_deps is False):
+        raise VarDependencyError("Cannot track dependencies without caching.")
+
     if fget is not None:
         return ComputedVar(fget=fget, cache=cache)
 
@@ -2236,6 +2292,7 @@ def computed_var(
             deps=deps,
             auto_deps=auto_deps,
             interval=interval,
+            backend=backend,
             **kwargs,
         )
 
@@ -2243,7 +2300,7 @@ def computed_var(
 
 
 # Partial function of computed_var with cache=True
-cached_var = functools.partial(computed_var, cache=True)
+cached_var = functools.partial(computed_var, cache=True, _deprecated_cached_var=True)
 
 
 class CallableVar(BaseVar):

reflex/vars.pyi

@@ -1,16 +1,9 @@
-""" Generated with stubgen from mypy, then manually edited, do not regen."""
+"""Generated with stubgen from mypy, then manually edited, do not regen."""
 
 from __future__ import annotations
 
 import datetime
 from dataclasses import dataclass
-from _typeshed import Incomplete
-from reflex import constants as constants
-from reflex.base import Base as Base
-from reflex.state import State as State
-from reflex.state import BaseState as BaseState
-from reflex.utils import console as console, format as format, types as types
-from reflex.utils.imports import ImportVar, ImportDict, ParsedImportDict
 from types import FunctionType
 from typing import (
     Any,
@@ -23,10 +16,21 @@ from typing import (
     Tuple,
     Type,
     Union,
-    overload,
     _GenericAlias,  # type: ignore
+    overload,
 )
 
+from _typeshed import Incomplete
+
+from reflex import constants as constants
+from reflex.base import Base as Base
+from reflex.state import BaseState as BaseState
+from reflex.state import State as State
+from reflex.utils import console as console
+from reflex.utils import format as format
+from reflex.utils import types as types
+from reflex.utils.imports import ImportDict, ParsedImportDict
+
 USED_VARIABLES: Incomplete
 
 def get_unique_variable_name() -> str: ...
@@ -51,11 +55,19 @@ class Var:
     _var_data: VarData | None = None
     @classmethod
     def create(
-        cls, value: Any, _var_is_local: bool = True, _var_is_string: bool | None = None, _var_data: VarData | None = None,
+        cls,
+        value: Any,
+        _var_is_local: bool = True,
+        _var_is_string: bool | None = None,
+        _var_data: VarData | None = None,
     ) -> Optional[Var]: ...
     @classmethod
     def create_safe(
-        cls, value: Any, _var_is_local: bool = True, _var_is_string: bool | None = None, _var_data: VarData | None = None,
+        cls,
+        value: Any,
+        _var_is_local: bool = True,
+        _var_is_string: bool | None = None,
+        _var_data: VarData | None = None,
     ) -> Var: ...
     @classmethod
     def __class_getitem__(cls, type_: Type) -> _GenericAlias: ...