reflex 0.8.5a2__py3-none-any.whl → 0.8.6a1__py3-none-any.whl

reflex/components/lucide/icon.py

@@ -6,7 +6,7 @@ from reflex.utils.imports import ImportVar
 from reflex.vars.base import LiteralVar, Var
 from reflex.vars.sequence import LiteralStringVar, StringVar
 
-LUCIDE_LIBRARY = "lucide-react@0.534.0"
+LUCIDE_LIBRARY = "lucide-react@0.536.0"
 
 
 class LucideIconComponent(Component):
@@ -93,6 +93,7 @@ class DynamicIcon(LucideIconComponent):
     tag = "DynamicIcon"
 
     name: Var[str]
+    size: Var[int]
 
     def _get_imports(self):
         _imports = super()._get_imports()
@@ -874,6 +875,7 @@ LUCIDE_ICON_LIST = [
     "hamburger",
     "hammer",
     "hand_coins",
+    "hand_fist",
     "hand_heart",
     "hand_helping",
     "hand_metal",
@@ -1644,6 +1646,7 @@ LUCIDE_ICON_LIST = [
     "truck_electric",
     "truck",
     "turkish_lira",
+    "turntable",
     "turtle",
     "tv_2",
     "tv_minimal_play",

reflex/components/lucide/icon.pyi

@@ -11,7 +11,7 @@ from reflex.components.core.breakpoints import Breakpoints
 from reflex.event import EventType, PointerEventInfo
 from reflex.vars.base import Var
 
-LUCIDE_LIBRARY = "lucide-react@0.534.0"
+LUCIDE_LIBRARY = "lucide-react@0.536.0"
 
 class LucideIconComponent(Component):
     @classmethod
@@ -125,6 +125,7 @@ class DynamicIcon(LucideIconComponent):
         cls,
         *children,
         name: Var[str] | str | None = None,
+        size: Var[int] | int | None = None,
         style: Sequence[Mapping[str, Any]]
         | Mapping[str, Any]
         | Var[Mapping[str, Any]]
@@ -939,6 +940,7 @@ LUCIDE_ICON_LIST = [
     "hamburger",
     "hammer",
     "hand_coins",
+    "hand_fist",
     "hand_heart",
     "hand_helping",
     "hand_metal",
@@ -1709,6 +1711,7 @@ LUCIDE_ICON_LIST = [
     "truck_electric",
     "truck",
     "turkish_lira",
+    "turntable",
     "turtle",
     "tv_2",
     "tv_minimal_play",

reflex/components/sonner/toast.py

@@ -171,7 +171,7 @@ class ToastProps(NoExtrasAllowedProps):
 class Toaster(Component):
     """A Toaster Component for displaying toast notifications."""
 
-    library: str | None = "sonner@2.0.6"
+    library: str | None = "sonner@2.0.7"
 
     tag = "Toaster"
 

reflex/config.py

@@ -29,6 +29,9 @@ from reflex.plugins.sitemap import SitemapPlugin
 from reflex.utils import console
 from reflex.utils.exceptions import ConfigError
 
+if TYPE_CHECKING:
+    from pyleak.base import LeakAction
+
 
 @dataclasses.dataclass(kw_only=True)
 class DBConfig:
@@ -186,6 +189,18 @@ class BaseConfig:
     # Telemetry opt-in.
     telemetry_enabled: bool = True
 
+    # PyLeak monitoring configuration for detecting event loop blocking and resource leaks.
+    enable_pyleak_monitoring: bool = False
+
+    # Threshold in seconds for detecting event loop blocking operations.
+    pyleak_blocking_threshold: float = 0.1
+
+    # Grace period in seconds for thread leak detection cleanup.
+    pyleak_thread_grace_period: float = 0.2
+
+    # Action to take when PyLeak detects issues
+    pyleak_action: "LeakAction | None" = None
+
     # The bun path
     bun_path: ExistingPath = constants.Bun.DEFAULT_PATH
 

reflex/constants/base.py

@@ -160,6 +160,9 @@ class ReactRouter(Javascript):
     # The react router config file
     CONFIG_FILE = "react-router.config.js"
 
+    # The associated Vite config file
+    VITE_CONFIG_FILE = "vite.config.js"
+
     # Regex to check for message displayed when frontend comes up
     DEV_FRONTEND_LISTENING_REGEX = r"Local:[\s]+"
 

reflex/istate/manager.py

@@ -143,6 +143,8 @@ class StateManagerMemory(StateManager):
             token: The token to set the state for.
             state: The state to set.
         """
+        token = _split_substate_key(token)[0]
+        self.states[token] = state
 
     @override
     @contextlib.asynccontextmanager
@@ -165,7 +167,6 @@ class StateManagerMemory(StateManager):
         async with self._states_locks[token]:
             state = await self.get_state(token)
             yield state
-            await self.set_state(token, state)
 
 
 def _default_token_expiration() -> int:

reflex/plugins/__init__.py

@@ -1,5 +1,6 @@
 """Reflex Plugin System."""
 
+from ._screenshot import ScreenshotPlugin as _ScreenshotPlugin
 from .base import CommonContext, Plugin, PreCompileContext
 from .sitemap import SitemapPlugin
 from .tailwind_v3 import TailwindV3Plugin
@@ -12,4 +13,5 @@ __all__ = [
     "SitemapPlugin",
     "TailwindV3Plugin",
     "TailwindV4Plugin",
+    "_ScreenshotPlugin",
 ]

reflex/plugins/_screenshot.py

@@ -0,0 +1,144 @@
+"""Plugin to enable screenshot functionality."""
+
+from typing import TYPE_CHECKING
+
+from reflex.plugins.base import Plugin as BasePlugin
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+    from starlette.responses import Response
+    from typing_extensions import Unpack
+
+    from reflex.app import App
+    from reflex.plugins.base import PostCompileContext
+    from reflex.state import BaseState
+
+ACTIVE_CONNECTIONS = "/_active_connections"
+CLONE_STATE = "/_clone_state"
+
+
+def _deep_copy(state: "BaseState") -> "BaseState":
+    """Create a deep copy of the state.
+
+    Args:
+        state: The state to copy.
+
+    Returns:
+        A deep copy of the state.
+    """
+    import copy
+
+    copy_of_state = copy.deepcopy(state)
+
+    def copy_substate(substate: "BaseState") -> "BaseState":
+        substate_copy = _deep_copy(substate)
+
+        substate_copy.parent_state = copy_of_state
+
+        return substate_copy
+
+    copy_of_state.substates = {
+        substate_name: copy_substate(substate)
+        for substate_name, substate in state.substates.items()
+    }
+
+    return copy_of_state
+
+
+class ScreenshotPlugin(BasePlugin):
+    """Plugin to handle screenshot functionality."""
+
+    def post_compile(self, **context: "Unpack[PostCompileContext]") -> None:
+        """Called after the compilation of the plugin.
+
+        Args:
+            context: The context for the plugin.
+        """
+        app = context["app"]
+        self._add_active_connections_endpoint(app)
+        self._add_clone_state_endpoint(app)
+
+    @staticmethod
+    def _add_active_connections_endpoint(app: "App") -> None:
+        """Add an endpoint to the app that returns the active connections.
+
+        Args:
+            app: The application instance to which the endpoint will be added.
+        """
+        if not app._api:
+            return
+
+        async def active_connections(_request: "Request") -> "Response":
+            from starlette.responses import JSONResponse
+
+            if not app.event_namespace:
+                return JSONResponse({})
+
+            return JSONResponse(app.event_namespace.token_to_sid)
+
+        app._api.add_route(
+            ACTIVE_CONNECTIONS,
+            active_connections,
+            methods=["GET"],
+        )
+
+    @staticmethod
+    def _add_clone_state_endpoint(app: "App") -> None:
+        """Add an endpoint to the app that clones the current state.
+
+        Args:
+            app: The application instance to which the endpoint will be added.
+        """
+        if not app._api:
+            return
+
+        async def clone_state(request: "Request") -> "Response":
+            import uuid
+
+            from starlette.responses import JSONResponse
+
+            from reflex.state import _substate_key
+
+            if not app.event_namespace:
+                return JSONResponse({})
+
+            token_to_clone = await request.json()
+
+            if not isinstance(token_to_clone, str):
+                return JSONResponse(
+                    {"error": "Token to clone must be a string."}, status_code=400
+                )
+
+            old_state = await app.state_manager.get_state(token_to_clone)
+
+            new_state = _deep_copy(old_state)
+
+            new_token = uuid.uuid4().hex
+
+            all_states = [new_state]
+
+            found_new = True
+
+            while found_new:
+                found_new = False
+
+                for state in all_states:
+                    for substate in state.substates.values():
+                        substate._was_touched = True
+
+                        if substate not in all_states:
+                            all_states.append(substate)
+
+                            found_new = True
+
+            await app.state_manager.set_state(
+                _substate_key(new_token, new_state), new_state
+            )
+
+            return JSONResponse(new_token)
+
+        app._api.add_route(
+            CLONE_STATE,
+            clone_state,
+            methods=["POST"],
+        )

reflex/plugins/base.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, ParamSpec, Protocol, TypedDict
 from typing_extensions import Unpack
 
 if TYPE_CHECKING:
-    from reflex.app import UnevaluatedPage
+    from reflex.app import App, UnevaluatedPage
 
 
 class CommonContext(TypedDict):
@@ -44,6 +44,12 @@ class PreCompileContext(CommonContext):
     unevaluated_pages: Sequence["UnevaluatedPage"]
 
 
+class PostCompileContext(CommonContext):
+    """Context for post-compile hooks."""
+
+    app: "App"
+
+
 class Plugin:
     """Base class for all plugins."""
 
@@ -104,6 +110,13 @@ class Plugin:
             context: The context for the plugin.
         """
 
+    def post_compile(self, **context: Unpack[PostCompileContext]) -> None:
+        """Called after the compilation of the plugin.
+
+        Args:
+            context: The context for the plugin.
+        """
+
     def __repr__(self):
         """Return a string representation of the plugin.
 

reflex/state.py

@@ -60,6 +60,7 @@ from reflex.utils.exceptions import (
 )
 from reflex.utils.exceptions import ImmutableStateError as ImmutableStateError
 from reflex.utils.exec import is_testing_env
+from reflex.utils.monitoring import is_pyleak_enabled, monitor_loopblocks
 from reflex.utils.types import _isinstance, is_union, value_inside_optional
 from reflex.vars import Field, VarData, field
 from reflex.vars.base import (
@@ -508,7 +509,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         new_backend_vars = {
             name: value
-            for name, value in cls.__dict__.items()
+            for name, value in list(cls.__dict__.items())
             if types.is_backend_base_variable(name, cls)
         }
         # Add annotated backend vars that may not have a default value.
@@ -1784,7 +1785,11 @@ class BaseState(EvenMoreBasicBaseState):
         from reflex.utils import telemetry
 
         # Get the function to process the event.
-        fn = functools.partial(handler.fn, state)
+        if is_pyleak_enabled():
+            console.debug(f"Monitoring leaks for handler: {handler.fn.__qualname__}")
+            fn = functools.partial(monitor_loopblocks(handler.fn), state)
+        else:
+            fn = functools.partial(handler.fn, state)
 
         try:
             type_hints = typing.get_type_hints(handler.fn)
@@ -2463,16 +2468,30 @@ class OnLoadInternalState(State):
     This is a separate substate to avoid deserializing the entire state tree for every page navigation.
     """
 
+    # Cannot properly annotate this as `App` due to circular import issues.
+    _app_ref: ClassVar[Any] = None
+
     def on_load_internal(self) -> list[Event | EventSpec | event.EventCallback] | None:
         """Queue on_load handlers for the current page.
 
         Returns:
             The list of events to queue for on load handling.
+
+        Raises:
+            TypeError: If the app reference is not of type App.
         """
-        # Do not app._compile()!  It should be already compiled by now.
-        load_events = prerequisites.get_and_validate_app().app.get_load_events(
-            self.router._page.path
-        )
+        from reflex.app import App
+
+        app = type(self)._app_ref or prerequisites.get_and_validate_app().app
+        if not isinstance(app, App):
+            msg = (
+                f"Expected app to be of type {App.__name__}, got {type(app).__name__}."
+            )
+            raise TypeError(msg)
+        # Cache the app reference for subsequent calls.
+        if type(self)._app_ref is None:
+            type(self)._app_ref = app
+        load_events = app.get_load_events(self.router._page.path)
         if not load_events:
             self.is_hydrated = True
             return None  # Fast path for navigation with no on_load events defined.
@@ -2646,6 +2665,9 @@ def reload_state_module(
         state: Recursive argument for the state class to reload.
 
     """
+    # Reset the _app_ref of OnLoadInternalState to avoid stale references.
+    if state is OnLoadInternalState:
+        state._app_ref = None
     # Clean out all potentially dirty states of reloaded modules.
     for pd_state in tuple(state._potentially_dirty_states):
         with contextlib.suppress(ValueError):

reflex/testing.py

@@ -376,6 +376,17 @@ class AppHarness:
                 msg = "Failed to reset state manager."
                 raise RuntimeError(msg)
 
+            # Also reset the TokenManager to avoid loop affinity issues
+            if (
+                hasattr(self.app_instance, "event_namespace")
+                and self.app_instance.event_namespace is not None
+                and hasattr(self.app_instance.event_namespace, "_token_manager")
+            ):
+                # Import here to avoid circular imports
+                from reflex.utils.token_manager import TokenManager
+
+                self.app_instance.event_namespace._token_manager = TokenManager.create()
+
     def _start_frontend(self):
         # Set up the frontend.
         with chdir(self.app_path):

reflex/utils/decorator.py

@@ -76,6 +76,7 @@ def debug(f: Callable[P, T]) -> Callable[P, T]:
 def _write_cached_procedure_file(payload: str, cache_file: Path, value: object):
     import pickle
 
+    cache_file.parent.mkdir(parents=True, exist_ok=True)
     cache_file.write_bytes(pickle.dumps((payload, value)))
 
 

reflex/utils/monitoring.py

@@ -0,0 +1,180 @@
+"""PyLeak integration for monitoring event loop blocking and resource leaks in Reflex applications."""
+
+import asyncio
+import contextlib
+import functools
+import inspect
+import threading
+from collections.abc import AsyncGenerator, Awaitable, Callable, Generator
+from typing import TypeVar, overload
+
+from reflex.config import get_config
+
+try:
+    from pyleak import no_event_loop_blocking, no_task_leaks, no_thread_leaks
+    from pyleak.base import LeakAction
+
+    PYLEAK_AVAILABLE = True
+except ImportError:
+    PYLEAK_AVAILABLE = False
+    no_event_loop_blocking = no_task_leaks = no_thread_leaks = None  # pyright: ignore[reportAssignmentType]
+    LeakAction = None  # pyright: ignore[reportAssignmentType]
+
+
+# Thread-local storage to track if monitoring is already active
+_thread_local = threading.local()
+
+
+def is_pyleak_enabled() -> bool:
+    """Check if PyLeak monitoring is enabled and available.
+
+    Returns:
+        True if PyLeak monitoring is enabled in config and PyLeak is available.
+    """
+    if not PYLEAK_AVAILABLE:
+        return False
+    config = get_config()
+    return config.enable_pyleak_monitoring
+
+
+@contextlib.contextmanager
+def monitor_sync():
+    """Sync context manager for PyLeak monitoring.
+
+    Yields:
+        None: Context for monitoring sync operations.
+    """
+    if not is_pyleak_enabled():
+        yield
+        return
+
+    # Check if monitoring is already active in this thread
+    if getattr(_thread_local, "monitoring_active", False):
+        yield
+        return
+
+    config = get_config()
+    action = config.pyleak_action or LeakAction.WARN  # pyright: ignore[reportOptionalMemberAccess]
+
+    # Mark monitoring as active
+    _thread_local.monitoring_active = True
+    try:
+        with contextlib.ExitStack() as stack:
+            # Thread leak detection has issues with background tasks (no_thread_leaks)
+            stack.enter_context(
+                no_event_loop_blocking(  # pyright: ignore[reportOptionalCall]
+                    action=action,
+                    threshold=config.pyleak_blocking_threshold,
+                )
+            )
+            yield
+    finally:
+        _thread_local.monitoring_active = False
+
+
+@contextlib.asynccontextmanager
+async def monitor_async():
+    """Async context manager for PyLeak monitoring.
+
+    Yields:
+        None: Context for monitoring async operations.
+    """
+    if not is_pyleak_enabled():
+        yield
+        return
+
+    # Check if monitoring is already active in this thread
+    if getattr(_thread_local, "monitoring_active", False):
+        yield
+        return
+
+    config = get_config()
+    action = config.pyleak_action or LeakAction.WARN  # pyright: ignore[reportOptionalMemberAccess]
+
+    # Mark monitoring as active
+    _thread_local.monitoring_active = True
+    try:
+        async with contextlib.AsyncExitStack() as stack:
+            # Thread leak detection has issues with background tasks (no_thread_leaks)
+            # Re-add thread leak later.
+
+            # Block detection for event loops
+            stack.enter_context(
+                no_event_loop_blocking(  # pyright: ignore[reportOptionalCall]
+                    action=action,
+                    threshold=config.pyleak_blocking_threshold,
+                )
+            )
+            # Task leak detection has issues with background tasks (no_task_leaks)
+
+            yield
+    finally:
+        _thread_local.monitoring_active = False
+
+
+YieldType = TypeVar("YieldType")
+SendType = TypeVar("SendType")
+ReturnType = TypeVar("ReturnType")
+
+
+@overload
+def monitor_loopblocks(
+    func: Callable[..., AsyncGenerator[YieldType, ReturnType]],
+) -> Callable[..., AsyncGenerator[YieldType, ReturnType]]: ...
+
+
+@overload
+def monitor_loopblocks(
+    func: Callable[..., Generator[YieldType, SendType, ReturnType]],
+) -> Callable[..., Generator[YieldType, SendType, ReturnType]]: ...
+
+
+@overload
+def monitor_loopblocks(
+    func: Callable[..., Awaitable[ReturnType]],
+) -> Callable[..., Awaitable[ReturnType]]: ...
+
+
+def monitor_loopblocks(func: Callable) -> Callable:
+    """Framework decorator using the monitoring module's context manager.
+
+    Args:
+        func: The function to be monitored for leaks.
+
+    Returns:
+        Decorator function that applies PyLeak monitoring to sync/async functions.
+    """
+    if inspect.isasyncgenfunction(func):
+
+        @functools.wraps(func)
+        async def async_gen_wrapper(*args, **kwargs):
+            async with monitor_async():
+                async for item in func(*args, **kwargs):
+                    yield item
+
+        return async_gen_wrapper
+
+    if asyncio.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            async with monitor_async():
+                return await func(*args, **kwargs)
+
+        return async_wrapper
+
+    if inspect.isgeneratorfunction(func):
+
+        @functools.wraps(func)
+        def gen_wrapper(*args, **kwargs):
+            with monitor_sync():
+                yield from func(*args, **kwargs)
+
+        return gen_wrapper
+
+    @functools.wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        with monitor_sync():
+            return func(*args, **kwargs)
+
+    return sync_wrapper  # pyright: ignore[reportReturnType]

reflex/utils/prerequisites.py

@@ -972,6 +972,9 @@ def initialize_web_directory():
     console.debug("Initializing the react-router.config.js file.")
     update_react_router_config()
 
+    console.debug("Initializing the vite.config.js file.")
+    initialize_vite_config()
+
     console.debug("Initializing the reflex.json file.")
     # Initialize the reflex json file.
     init_reflex_json(project_hash=project_hash)
@@ -996,6 +999,20 @@ def initialize_package_json():
     output_path.write_text(_compile_package_json())
 
 
+def _compile_vite_config(config: Config):
+    # base must have exactly one trailing slash
+    base = "/"
+    if frontend_path := config.frontend_path.strip("/"):
+        base += frontend_path + "/"
+    return templates.VITE_CONFIG.render(base=base)
+
+
+def initialize_vite_config():
+    """Render and write in .web the vite.config.js file using Reflex config."""
+    vite_config_file_path = get_web_dir() / constants.ReactRouter.VITE_CONFIG_FILE
+    vite_config_file_path.write_text(_compile_vite_config(get_config()))
+
+
 def initialize_bun_config():
     """Initialize the bun config file."""
     bun_config_path = get_web_dir() / constants.Bun.CONFIG_PATH