Merge remote-tracking branch 'origin/main' into release/reflex-0.8.20

Author: adhami3310

.github/codeql-config.yml

@@ -1,2 +1,6 @@
+paths:
+  - .github
+  - reflex
+  - reflex/.templates
 paths-ignore:
   - "**/tests/**"

.github/workflows/codeql.yml

@@ -69,7 +69,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         with:
           languages: ${{ matrix.language }}
           config-file: .github/codeql-config.yml
@@ -98,6 +98,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
         with:
           category: "/language:${{matrix.language}}"

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

@@ -618,19 +618,13 @@ export const connect = async (
     window.addEventListener("unload", disconnectTrigger);
     if (socket.current.rehydrate) {
       socket.current.rehydrate = false;
-      const events = initialEvents();
-      if (events.length > 0) {
-        // On reconnect, we only hydrate, do not re-run on_load events.
-        const hydrate_event = initialEvents()[0];
-        hydrate_event.payload.is_reconnect = true;
-        queueEvents(
-          [hydrate_event],
-          socket,
-          true,
-          navigate,
-          () => params.current,
-        );
-      }
+      queueEvents(
+        initialEvents(),
+        socket,
+        true,
+        navigate,
+        () => params.current,
+      );
     }
     // Drain any initial events from the queue.
     while (event_queue.length > 0 && !event_processing) {

reflex/app.py

@@ -529,19 +529,6 @@ def _setup_state(self) -> None:
 
         # Set up the Socket.IO AsyncServer.
         if not self.sio:
-            if (
-                config.transport == "polling"
-                and (tier := prerequisites.get_user_tier()) != "enterprise"
-            ):
-                console.error(
-                    "The 'polling' transport is only available for Enterprise users. "
-                    + (
-                        "Please upgrade your plan to use this feature."
-                        if tier != "anonymous"
-                        else "Please log in with `reflex login` to use this feature."
-                    )
-                )
-                raise SystemExit(1)
             self.sio = AsyncServer(
                 async_mode="asgi",
                 cors_allowed_origins=(

reflex/istate/proxy.py

@@ -553,18 +553,17 @@ def __getattr__(self, __name: str) -> Any:
                 value = wrapt.FunctionWrapper(value, self._mark_dirty)
 
             if __name in self.__wrap_mutable_attrs__:
-                # Wrap methods that may return mutable objects tied to the state.
+                # Wrap special methods that may return mutable objects tied to the state.
                 value = wrapt.FunctionWrapper(
                     value,
                     self._wrap_recursive_decorator,  # pyright: ignore[reportArgumentType]
                 )
 
             if (
-                isinstance(self.__wrapped__, Base)
-                and __name not in NEVER_WRAP_BASE_ATTRS
-                and hasattr(value, "__func__")
-            ):
-                # Wrap methods called on Base subclasses, which might do _anything_
+                not isinstance(self.__wrapped__, Base)
+                or __name not in NEVER_WRAP_BASE_ATTRS
+            ) and hasattr(value, "__func__"):
+                # Wrap methods which might do _anything_
                 return wrapt.FunctionWrapper(
                     functools.partial(value.__func__, self),  # pyright: ignore [reportFunctionMemberAccess, reportAttributeAccessIssue]
                     self._wrap_recursive_decorator,  # pyright: ignore[reportArgumentType]

reflex/middleware/hydrate_middleware.py

@@ -35,14 +35,11 @@ async def preprocess(
         if event.name != get_hydrate_event(state):
             return None
 
-        # In reconnect mode, don't reset client storage or call on_load.
-        is_reconnect = event.payload.get("is_reconnect", False)
-        if not is_reconnect:
-            # Clear client storage, to respect clearing cookies
-            state._reset_client_storage()
-
-            # Mark state as not hydrated (until on_loads are complete)
-            setattr(state, constants.CompileVars.IS_HYDRATED, False)
+        # Clear client storage, to respect clearing cookies
+        state._reset_client_storage()
+
+        # Mark state as not hydrated (until on_loads are complete)
+        setattr(state, constants.CompileVars.IS_HYDRATED, False)
 
         # Get the initial state.
         delta = await _resolve_delta(state.dict())

reflex/utils/token_manager.py

@@ -229,16 +229,22 @@ async def enumerate_tokens(self) -> AsyncIterator[str]:
             if not cursor:
                 break
 
-    def _handle_socket_record_del(self, token: str) -> None:
+    async def _handle_socket_record_del(
+        self, token: str, expired: bool = False
+    ) -> None:
         """Handle deletion of a socket record from Redis.
 
         Args:
             token: The client token whose record was deleted.
+            expired: Whether the deletion was due to expiration.
         """
         if (
             socket_record := self.token_to_socket.pop(token, None)
-        ) is not None and socket_record.instance_id != self.instance_id:
+        ) is not None and socket_record.instance_id == self.instance_id:
             self.sid_to_token.pop(socket_record.sid, None)
+            if expired:
+                # Keep the record alive as long as this process is alive and not deleted.
+                await self.link_token_to_sid(token, socket_record.sid)
 
     async def _subscribe_socket_record_updates(self) -> None:
         """Subscribe to Redis keyspace notifications for socket record updates."""
@@ -262,7 +268,10 @@ async def _subscribe_socket_record_updates(self) -> None:
 
                     event = message["data"].decode()
                     if event in ("del", "expired", "evicted"):
-                        self._handle_socket_record_del(token)
+                        await self._handle_socket_record_del(
+                            token,
+                            expired=(event == "expired"),
+                        )
                     elif event == "set":
                         await self._get_token_owner(token, refresh=True)
 

tests/units/test_state.py

@@ -2055,6 +2055,22 @@ class ModelDC:
     foo: str = "bar"
     ls: list[dict] = dataclasses.field(default_factory=list)
 
+    def set_foo(self, val: str):
+        """Set the attribute foo.
+
+        Args:
+            val: The value to set.
+        """
+        self.foo = val
+
+    def double_foo(self) -> str:
+        """Concatenate foo with foo.
+
+        Returns:
+            foo + foo
+        """
+        return self.foo + self.foo
+
 
 @pytest.mark.asyncio
 async def test_state_proxy(
@@ -3806,12 +3822,44 @@ class ModelV1(BaseModelV1):
 
     foo: str = "bar"
 
+    def set_foo(self, val: str):
+        """Set the attribute foo.
+
+        Args:
+            val: The value to set.
+        """
+        self.foo = val
+
+    def double_foo(self) -> str:
+        """Concatenate foo with foo.
+
+        Returns:
+            foo + foo
+        """
+        return self.foo + self.foo
+
 
 class ModelV2(BaseModelV2):
     """A pydantic BaseModel v2."""
 
     foo: str = "bar"
 
+    def set_foo(self, val: str):
+        """Set the attribute foo.
+
+        Args:
+            val: The value to set.
+        """
+        self.foo = val
+
+    def double_foo(self) -> str:
+        """Concatenate foo with foo.
+
+        Returns:
+            foo + foo
+        """
+        return self.foo + self.foo
+
 
 class PydanticState(rx.State):
     """A state with pydantic BaseModel vars."""
@@ -3828,26 +3876,46 @@ def test_mutable_models():
     state.v1.foo = "baz"
     assert state.dirty_vars == {"v1"}
     state.dirty_vars.clear()
+    state.v1.set_foo("quuc")
+    assert state.dirty_vars == {"v1"}
+    state.dirty_vars.clear()
+    assert state.v1.double_foo() == "quucquuc"
+    assert state.dirty_vars == set()
+    state.v1.copy(update={"foo": "larp"})
+    assert state.dirty_vars == set()
 
     assert isinstance(state.v2, MutableProxy)
     state.v2.foo = "baz"
     assert state.dirty_vars == {"v2"}
     state.dirty_vars.clear()
+    state.v2.set_foo("quuc")
+    assert state.dirty_vars == {"v2"}
+    state.dirty_vars.clear()
+    assert state.v2.double_foo() == "quucquuc"
+    assert state.dirty_vars == set()
+    state.v2.model_copy(update={"foo": "larp"})
+    assert state.dirty_vars == set()
 
     assert isinstance(state.dc, MutableProxy)
     state.dc.foo = "baz"
     assert state.dirty_vars == {"dc"}
     state.dirty_vars.clear()
     assert state.dirty_vars == set()
+    state.dc.set_foo("quuc")
+    assert state.dirty_vars == {"dc"}
+    state.dirty_vars.clear()
+    assert state.dirty_vars == set()
+    assert state.dc.double_foo() == "quucquuc"
+    assert state.dirty_vars == set()
     state.dc.ls.append({"hi": "reflex"})
     assert state.dirty_vars == {"dc"}
     state.dirty_vars.clear()
     assert state.dirty_vars == set()
-    assert dataclasses.asdict(state.dc) == {"foo": "baz", "ls": [{"hi": "reflex"}]}
-    assert dataclasses.astuple(state.dc) == ("baz", [{"hi": "reflex"}])
+    assert dataclasses.asdict(state.dc) == {"foo": "quuc", "ls": [{"hi": "reflex"}]}
+    assert dataclasses.astuple(state.dc) == ("quuc", [{"hi": "reflex"}])
     # creating a new instance shouldn't mark the state dirty
-    assert dataclasses.replace(state.dc, foo="quuc") == ModelDC(
-        foo="quuc", ls=[{"hi": "reflex"}]
+    assert dataclasses.replace(state.dc, foo="larp") == ModelDC(
+        foo="larp", ls=[{"hi": "reflex"}]
     )
     assert state.dirty_vars == set()