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

Author: adhami3310

.github/workflows/integration_tests.yml

@@ -122,6 +122,7 @@ jobs:
           repository: reflex-dev/reflex-web
           ref: main
           path: reflex-web
+          submodules: recursive
 
       - name: Compile pyproject.toml into requirements.txt
         working-directory: ./reflex-web
@@ -189,6 +190,7 @@ jobs:
           repository: reflex-dev/reflex-web
           ref: main
           path: reflex-web
+          submodules: recursive
       - name: Compile pyproject.toml into requirements.txt
         working-directory: ./reflex-web
         run: |

pyi_hashes.json

@@ -1,5 +1,5 @@
 {
-  "reflex/__init__.pyi": "b304ed6f7a2fa028a194cad81bd83112",
+  "reflex/__init__.pyi": "0a3ae880e256b9fd3b960e12a2cb51a7",
   "reflex/components/__init__.pyi": "ac05995852baa81062ba3d18fbc489fb",
   "reflex/components/base/__init__.pyi": "16e47bf19e0d62835a605baa3d039c5a",
   "reflex/components/base/app_wrap.pyi": "22e94feaa9fe675bcae51c412f5b67f1",

reflex/.templates/web/utils/helpers/paste.js

@@ -1,4 +1,4 @@
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 
 const handle_paste_data = (clipboardData) =>
   new Promise((resolve, reject) => {
@@ -35,25 +35,71 @@ const handle_paste_data = (clipboardData) =>
   });
 
 export default function usePasteHandler(target_ids, event_actions, on_paste) {
-  return useEffect(() => {
+  const onPasteRef = useRef(on_paste);
+  const eventActionsRef = useRef(event_actions);
+
+  useEffect(() => {
+    onPasteRef.current = on_paste;
+  }, [on_paste]);
+  useEffect(() => {
+    eventActionsRef.current = event_actions;
+  }, [event_actions]);
+
+  useEffect(() => {
     const handle_paste = (_ev) => {
-      event_actions.preventDefault && _ev.preventDefault();
-      event_actions.stopPropagation && _ev.stopPropagation();
-      handle_paste_data(_ev.clipboardData).then(on_paste);
+      eventActionsRef.current?.preventDefault && _ev.preventDefault();
+      eventActionsRef.current?.stopPropagation && _ev.stopPropagation();
+      handle_paste_data(_ev.clipboardData).then(onPasteRef.current);
     };
-    const targets = target_ids
-      .map((id) => document.getElementById(id))
-      .filter((element) => !!element);
-    if (target_ids.length === 0) {
-      targets.push(document);
-    }
-    targets.forEach((target) =>
-      target.addEventListener("paste", handle_paste, false),
-    );
-    return () => {
+
+    let cleanupListeners = null;
+    let observer = null;
+
+    const attachListeners = (targets) => {
       targets.forEach((target) =>
-        target.removeEventListener("paste", handle_paste, false),
+        target.addEventListener("paste", handle_paste, false),
       );
+      return () => {
+        targets.forEach((target) =>
+          target.removeEventListener("paste", handle_paste, false),
+        );
+      };
     };
-  });
+
+    const tryAttach = () => {
+      if (target_ids.length === 0) {
+        cleanupListeners = attachListeners([document]);
+        return true;
+      }
+      const targets = target_ids
+        .map((id) => document.getElementById(id))
+        .filter((element) => !!element);
+
+      if (targets.length === target_ids.length) {
+        cleanupListeners = attachListeners(targets);
+        return true;
+      }
+
+      return false;
+    };
+
+    if (!tryAttach()) {
+      observer = new MutationObserver(() => {
+        if (tryAttach()) {
+          observer.disconnect();
+          observer = null;
+        }
+      });
+      observer.observe(document.body, { childList: true, subtree: true });
+    }
+
+    return () => {
+      if (observer) {
+        observer.disconnect();
+      }
+      if (cleanupListeners) {
+        cleanupListeners();
+      }
+    };
+  }, [target_ids]);
 }

reflex/__init__.py

@@ -336,6 +336,7 @@
         "State",
         "dynamic",
     ],
+    "istate.shared": ["SharedState"],
     "istate.wrappers": ["get_state"],
     "style": ["Style", "toggle_color_mode"],
     "utils.imports": ["ImportDict", "ImportVar"],

reflex/app.py

@@ -1562,13 +1562,17 @@ def all_routes(_request: Request) -> Response:
 
     @contextlib.asynccontextmanager
     async def modify_state(
-        self, token: str, background: bool = False
+        self,
+        token: str,
+        background: bool = False,
+        previous_dirty_vars: dict[str, set[str]] | None = None,
     ) -> AsyncIterator[BaseState]:
         """Modify the state out of band.
 
         Args:
             token: The token to modify the state for.
             background: Whether the modification is happening in a background task.
+            previous_dirty_vars: Vars that are considered dirty from a previous operation.
 
         Yields:
             The state to modify.
@@ -1581,7 +1585,9 @@ async def modify_state(
             raise RuntimeError(msg)
 
         # Get exclusive access to the state.
-        async with self.state_manager.modify_state(token) as state:
+        async with self.state_manager.modify_state_with_links(
+            token, previous_dirty_vars=previous_dirty_vars
+        ) as state:
             # No other event handler can modify the state while in this context.
             yield state
             delta = await state._get_resolved_delta()
@@ -1769,7 +1775,7 @@ async def process(
             constants.RouteVar.CLIENT_IP: client_ip,
         })
         # Get the state for the session exclusively.
-        async with app.state_manager.modify_state(
+        async with app.state_manager.modify_state_with_links(
             event.substate_token, event=event
         ) as state:
             # When this is a brand new instance of the state, signal the
@@ -2003,7 +2009,9 @@ async def _ndjson_updates():
                 Each state update as JSON followed by a new line.
             """
             # Process the event.
-            async with app.state_manager.modify_state(event.substate_token) as state:
+            async with app.state_manager.modify_state_with_links(
+                event.substate_token
+            ) as state:
                 async for update in state._process(event):
                     # Postprocess the event.
                     update = await app._postprocess(state, event, update)

reflex/compiler/templates.py

@@ -585,6 +585,9 @@ def vite_config_template(
     enableNativePlugin: false,
     hmr: {"true" if experimental_hmr else "false"},
   }},
+  legacy: {{
+    inconsistentCjsInterop: true,
+  }},
   server: {{
     port: process.env.PORT,
     hmr: {"true" if hmr else "false"},

reflex/istate/manager/__init__.py

@@ -114,6 +114,35 @@ async def modify_state(
         """
         yield self.state()
 
+    @contextlib.asynccontextmanager
+    async def modify_state_with_links(
+        self,
+        token: str,
+        previous_dirty_vars: dict[str, set[str]] | None = None,
+        **context: Unpack[StateModificationContext],
+    ) -> AsyncIterator[BaseState]:
+        """Modify the state for a token, including linked substates, while holding exclusive lock.
+
+        Args:
+            token: The token to modify the state for.
+            previous_dirty_vars: The previously dirty vars for linked states.
+            context: The state modification context.
+
+        Yields:
+            The state for the token with linked states patched in.
+        """
+        async with self.modify_state(token, **context) as root_state:
+            if getattr(root_state, "_reflex_internal_links", None) is not None:
+                from reflex.istate.shared import SharedStateBaseInternal
+
+                shared_state = await root_state.get_state(SharedStateBaseInternal)
+                async with shared_state._modify_linked_states(
+                    previous_dirty_vars=previous_dirty_vars
+                ) as _:
+                    yield root_state
+            else:
+                yield root_state
+
     async def close(self):  # noqa: B027
         """Close the state manager."""
 

reflex/istate/proxy.py

@@ -560,11 +560,15 @@ def __getattr__(self, __name: str) -> Any:
                 )
 
             if (
-                not isinstance(self.__wrapped__, Base)
-                or __name not in NEVER_WRAP_BASE_ATTRS
-            ) and hasattr(value, "__func__"):
+                (
+                    not isinstance(self.__wrapped__, Base)
+                    or __name not in NEVER_WRAP_BASE_ATTRS
+                )
+                and (func := getattr(value, "__func__", None)) is not None
+                and not inspect.isclass(getattr(value, "__self__", None))
+            ):
                 # Rebind `self` to the proxy on methods to capture nested mutations.
-                return functools.partial(value.__func__, self)  # pyright: ignore [reportFunctionMemberAccess, reportAttributeAccessIssue]
+                return functools.partial(func, self)
 
         if is_mutable_type(type(value)) and __name not in (
             "__wrapped__",