Merge remote-tracking branch 'origin/main' into masenf/exec-with-sys-executable

Author: masenf

pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
   "click >=8.2",
   "granian[reload] >=2.5.5",
   "httpx >=0.23.3,<1.0",
-  "packaging >=24.2,<26",
+  "packaging >=24.2,<27",
   "platformdirs >=4.3.7,<5.0",
   "psutil >=7.0.0,<8.0; sys_platform == 'win32'",
   "pydantic >=1.10.21,<3.0",

reflex/.templates/web/utils/state.js

@@ -446,6 +446,16 @@ export const applyRestEvent = async (event, socket, navigate, params) => {
   return eventSent;
 };
 
+/**
+ * Resolve a socket reference to the actual socket object.
+ * Handles both ref objects ({ current: Socket }) and raw sockets.
+ * @param socket Either a ref object or raw socket.
+ * @returns The actual socket object.
+ */
+const resolveSocket = (socket) => {
+  return socket?.current ?? socket;
+};
+
 /**
  * Queue events to be processed and trigger processing of queue.
  * @param events Array of events to queue.
@@ -471,7 +481,7 @@ export const queueEvents = async (
     ];
   }
   event_queue.push(...events.filter((e) => e !== undefined && e !== null));
-  await processEvent(socket.current, navigate, params);
+  await processEvent(resolveSocket(socket), navigate, params);
 };
 
 /**

reflex/event.py

@@ -89,6 +89,7 @@ def substate_token(self) -> str:
 _EVENT_FIELDS: set[str] = {f.name for f in dataclasses.fields(Event)}
 
 BACKGROUND_TASK_MARKER = "_reflex_background_task"
+EVENT_ACTIONS_MARKER = "_rx_event_actions"
 
 
 @dataclasses.dataclass(
@@ -2311,6 +2312,7 @@ class EventNamespace:
 
     # Constants
     BACKGROUND_TASK_MARKER = BACKGROUND_TASK_MARKER
+    EVENT_ACTIONS_MARKER = EVENT_ACTIONS_MARKER
     _EVENT_FIELDS = _EVENT_FIELDS
     FORM_DATA = FORM_DATA
     upload_files = upload_files
@@ -2461,7 +2463,7 @@ def wrapper(
             # Store decorator event actions on the function for later processing
             event_actions = _build_event_actions()
             if event_actions:
-                func._rx_event_actions = event_actions  # pyright: ignore [reportFunctionMemberAccess]
+                setattr(func, EVENT_ACTIONS_MARKER, event_actions)
             return func  # pyright: ignore [reportReturnType]
 
         if func is not None:

reflex/istate/proxy.py

@@ -26,6 +26,7 @@
     from reflex.state import BaseState, StateUpdate
 
 T_STATE = TypeVar("T_STATE", bound="BaseState")
+T = TypeVar("T")
 
 
 class StateProxy(wrapt.ObjectProxy):
@@ -671,19 +672,23 @@ def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Any:
         return copy.deepcopy(self.__wrapped__, memo=memo)
 
     def __reduce_ex__(self, protocol_version: SupportsIndex):
-        """Get the state for redis serialization.
+        """Serialize the wrapped object for pickle, stripping off the proxy.
 
-        This method is called by cloudpickle to serialize the object.
-
-        It explicitly serializes the wrapped object, stripping off the mutable proxy.
+        Returns a function that reconstructs to the wrapped object directly,
+        ensuring pickle's memo system correctly tracks object identity.
 
         Args:
             protocol_version: The protocol version.
 
         Returns:
-            Tuple of (wrapped class, empty args, class __getstate__)
+            Tuple that reconstructs to the wrapped object.
         """
-        return self.__wrapped__.__reduce_ex__(protocol_version)
+        return (_unwrap_for_pickle, (self.__wrapped__,))
+
+
+def _unwrap_for_pickle(obj: T) -> T:
+    """Return the object unchanged. Used by MutableProxy.__reduce_ex__."""
+    return obj
 
 
 @serializer

reflex/state.py

@@ -42,6 +42,7 @@
 from reflex.environment import PerformanceMode, environment
 from reflex.event import (
     BACKGROUND_TASK_MARKER,
+    EVENT_ACTIONS_MARKER,
     Event,
     EventHandler,
     EventSpec,
@@ -686,6 +687,9 @@ def _copy_fn(fn: Callable) -> Callable:
         newfn.__annotations__ = fn.__annotations__
         if mark := getattr(fn, BACKGROUND_TASK_MARKER, None):
             setattr(newfn, BACKGROUND_TASK_MARKER, mark)
+        # Preserve event_actions from @rx.event decorator
+        if event_actions := getattr(fn, EVENT_ACTIONS_MARKER, None):
+            object.__setattr__(newfn, EVENT_ACTIONS_MARKER, event_actions)
         return newfn
 
     @staticmethod
@@ -1163,7 +1167,7 @@ def _create_event_handler(
             The event handler.
         """
         # Check if function has stored event_actions from decorator
-        event_actions = getattr(fn, "_rx_event_actions", {})
+        event_actions = getattr(fn, EVENT_ACTIONS_MARKER, {})
 
         return event_handler_cls(
             fn=fn, state_full_name=cls.get_full_name(), event_actions=event_actions

tests/units/istate/test_proxy.py

@@ -0,0 +1,37 @@
+"""Tests for MutableProxy pickle behavior."""
+
+import dataclasses
+import pickle
+
+import reflex as rx
+from reflex.istate.proxy import MutableProxy
+
+
+@dataclasses.dataclass
+class Item:
+    """Simple picklable object for testing."""
+
+    id: int
+
+
+class ProxyTestState(rx.State):
+    """Test state with a list field."""
+
+    items: list[Item] = []
+
+
+def test_mutable_proxy_pickle_preserves_object_identity():
+    """Test that same object referenced directly and via proxy maintains identity."""
+    state = ProxyTestState()
+    obj = Item(1)
+
+    data = {
+        "direct": [obj],
+        "proxied": [MutableProxy(obj, state, "items")],
+    }
+
+    unpickled = pickle.loads(pickle.dumps(data))
+
+    assert unpickled["direct"][0].id == 1
+    assert unpickled["proxied"][0].id == 1
+    assert unpickled["direct"][0] is unpickled["proxied"][0]

tests/units/test_state.py

@@ -3737,6 +3737,21 @@ def test_bare_mixin_state() -> None:
     assert ChildBareMixinState.get_root_state() == State
 
 
+def test_mixin_event_handler_preserves_event_actions() -> None:
+    """Test that event_actions from @rx.event decorator are preserved when inherited from mixins."""
+
+    class EventActionsMixin(BaseState, mixin=True):
+        @rx.event(prevent_default=True, stop_propagation=True)
+        def handle_with_actions(self):
+            pass
+
+    class UsesEventActionsMixin(EventActionsMixin, State):
+        pass
+
+    handler = UsesEventActionsMixin.handle_with_actions
+    assert handler.event_actions == {"preventDefault": True, "stopPropagation": True}
+
+
 def test_assignment_to_undeclared_vars():
     """Test that an attribute error is thrown when undeclared vars are set."""
 
@@ -4453,9 +4468,5 @@ async def test_rebind_mutable_proxy(mock_app: rx.App, token: str) -> None:
     ) as state:
         assert isinstance(state, MutableProxyState)
         assert state.data["a"] == [2, 3]
-        if isinstance(mock_app.state_manager, StateManagerRedis):
-            # In redis mode, the object identity does not persist across async with self calls.
-            assert state.data["b"] == [2]
-        else:
-            # In disk/memory mode, the fact that data["b"] was mutated via data["a"] persists.
-            assert state.data["b"] == [2, 3]
+        # Object identity persists across serialization, so data["b"] is also mutated.
+        assert state.data["b"] == [2, 3]