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

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

reflex/utils/token_manager.py

@@ -0,0 +1,215 @@
+"""Token manager for handling client token to session ID mappings."""
+
+from __future__ import annotations
+
+import uuid
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from reflex.utils import console, prerequisites
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+
+
+def _get_new_token() -> str:
+    """Generate a new unique token.
+
+    Returns:
+        A new UUID4 token string.
+    """
+    return str(uuid.uuid4())
+
+
+class TokenManager(ABC):
+    """Abstract base class for managing client token to session ID mappings."""
+
+    def __init__(self):
+        """Initialize the token manager with local dictionaries."""
+        # Keep a mapping between socket ID and client token.
+        self.token_to_sid: dict[str, str] = {}
+        # Keep a mapping between client token and socket ID.
+        self.sid_to_token: dict[str, str] = {}
+
+    @abstractmethod
+    async def link_token_to_sid(self, token: str, sid: str) -> str | None:
+        """Link a token to a session ID.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+
+        Returns:
+            New token if duplicate detected and new token generated, None otherwise.
+        """
+
+    @abstractmethod
+    async def disconnect_token(self, token: str, sid: str) -> None:
+        """Clean up token mapping when client disconnects.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+        """
+
+    @classmethod
+    def create(cls) -> TokenManager:
+        """Factory method to create appropriate TokenManager implementation.
+
+        Returns:
+            RedisTokenManager if Redis is available, LocalTokenManager otherwise.
+        """
+        if prerequisites.check_redis_used():
+            redis_client = prerequisites.get_redis()
+            if redis_client is not None:
+                return RedisTokenManager(redis_client)
+
+        return LocalTokenManager()
+
+
+class LocalTokenManager(TokenManager):
+    """Token manager using local in-memory dictionaries (single worker)."""
+
+    def __init__(self):
+        """Initialize the local token manager."""
+        super().__init__()
+
+    async def link_token_to_sid(self, token: str, sid: str) -> str | None:
+        """Link a token to a session ID.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+
+        Returns:
+            New token if duplicate detected and new token generated, None otherwise.
+        """
+        # Check if token is already mapped to a different SID (duplicate tab)
+        if token in self.token_to_sid and sid != self.token_to_sid.get(token):
+            new_token = _get_new_token()
+            self.token_to_sid[new_token] = sid
+            self.sid_to_token[sid] = new_token
+            return new_token
+
+        # Normal case - link token to SID
+        self.token_to_sid[token] = sid
+        self.sid_to_token[sid] = token
+        return None
+
+    async def disconnect_token(self, token: str, sid: str) -> None:
+        """Clean up token mapping when client disconnects.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+        """
+        # Clean up both mappings
+        self.token_to_sid.pop(token, None)
+        self.sid_to_token.pop(sid, None)
+
+
+class RedisTokenManager(LocalTokenManager):
+    """Token manager using Redis for distributed multi-worker support.
+
+    Inherits local dict logic from LocalTokenManager and adds Redis layer
+    for cross-worker duplicate detection.
+    """
+
+    def __init__(self, redis: Redis):
+        """Initialize the Redis token manager.
+
+        Args:
+            redis: The Redis client instance.
+        """
+        # Initialize parent's local dicts
+        super().__init__()
+
+        self.redis = redis
+
+        # Get token expiration from config (default 1 hour)
+        from reflex.config import get_config
+
+        config = get_config()
+        self.token_expiration = config.redis_token_expiration
+
+    def _get_redis_key(self, token: str) -> str:
+        """Get Redis key for token mapping.
+
+        Args:
+            token: The client token.
+
+        Returns:
+            Redis key following Reflex conventions: {token}_sid
+        """
+        return f"{token}_sid"
+
+    async def link_token_to_sid(self, token: str, sid: str) -> str | None:
+        """Link a token to a session ID with Redis-based duplicate detection.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+
+        Returns:
+            New token if duplicate detected and new token generated, None otherwise.
+        """
+        # Fast local check first (handles reconnections)
+        if token in self.token_to_sid and self.token_to_sid[token] == sid:
+            return None  # Same token, same SID = reconnection, no Redis check needed
+
+        # Check Redis for cross-worker duplicates
+        redis_key = self._get_redis_key(token)
+
+        try:
+            token_exists_in_redis = await self.redis.exists(redis_key)
+        except Exception as e:
+            console.error(f"Redis error checking token existence: {e}")
+            return await super().link_token_to_sid(token, sid)
+
+        if token_exists_in_redis:
+            # Duplicate exists somewhere - generate new token
+            new_token = _get_new_token()
+            new_redis_key = self._get_redis_key(new_token)
+
+            try:
+                # Store in Redis
+                await self.redis.set(new_redis_key, "1", ex=self.token_expiration)
+            except Exception as e:
+                console.error(f"Redis error storing new token: {e}")
+                # Still update local dicts and continue
+
+            # Store in local dicts (always do this)
+            self.token_to_sid[new_token] = sid
+            self.sid_to_token[sid] = new_token
+            return new_token
+
+        # Normal case - store in both Redis and local dicts
+        try:
+            await self.redis.set(redis_key, "1", ex=self.token_expiration)
+        except Exception as e:
+            console.error(f"Redis error storing token: {e}")
+            # Continue with local storage
+
+        # Store in local dicts (always do this)
+        self.token_to_sid[token] = sid
+        self.sid_to_token[sid] = token
+        return None
+
+    async def disconnect_token(self, token: str, sid: str) -> None:
+        """Clean up token mapping when client disconnects.
+
+        Args:
+            token: The client token.
+            sid: The Socket.IO session ID.
+        """
+        # Only clean up if we own it locally (fast ownership check)
+        if self.token_to_sid.get(token) == sid:
+            # Clean up Redis
+            redis_key = self._get_redis_key(token)
+            try:
+                await self.redis.delete(redis_key)
+            except Exception as e:
+                console.error(f"Redis error deleting token: {e}")
+
+            # Clean up local dicts (always do this)
+            await super().disconnect_token(token, sid)

{reflex-0.8.5a1.dist-info → reflex-0.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.8.5a1
+Version: 0.8.6
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex
@@ -36,6 +36,8 @@ Requires-Dist: sqlmodel<0.1,>=0.0.24
 Requires-Dist: starlette>=0.47.0
 Requires-Dist: typing-extensions>=4.13.0
 Requires-Dist: wrapt<2.0,>=1.17.0
+Provides-Extra: monitoring
+Requires-Dist: pyleak<1.0,>=0.1.14; extra == 'monitoring'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -50,6 +52,7 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/Documentation%20-Introduction%20-%20%23007ec6)](https://reflex.dev/docs/getting-started/introduction)
 [![PyPI Downloads](https://static.pepy.tech/badge/reflex)](https://pepy.tech/projects/reflex)
 [![Discord](https://img.shields.io/discord/1029853095527727165?color=%237289da&label=Discord)](https://discord.gg/T5WSbC2YtQ)
+[![Twitter](https://img.shields.io/twitter/follow/getreflex)](https://x.com/getreflex)
 
 </div>
 
@@ -242,7 +245,7 @@ def get_image(self):
 
 Within the state, we define functions called event handlers that change the state vars. Event handlers are the way that we can modify the state in Reflex. They can be called in response to user actions, such as clicking a button or typing in a text box. These actions are called events.
 
-Our DALL·E. app has an event handler, `get_image` to which get this image from the OpenAI API. Using `yield` in the middle of an event handler will cause the UI to update. Otherwise the UI will update at the end of the event handler.
+Our DALL·E app has an event handler, `get_image` which gets this image from the OpenAI API. Using `yield` in the middle of an event handler will cause the UI to update. Otherwise the UI will update at the end of the event handler.
 
 ### **Routing**