Merge remote-tracking branch 'origin/main' into hide-__getattribute__-from-type-checking

Author: adhami3310

pyi_hashes.json

@@ -23,7 +23,7 @@
   "reflex/components/core/window_events.pyi": "af33ccec866b9540ee7fbec6dbfbd151",
   "reflex/components/datadisplay/__init__.pyi": "52755871369acbfd3a96b46b9a11d32e",
   "reflex/components/datadisplay/code.pyi": "b86769987ef4d1cbdddb461be88539fd",
-  "reflex/components/datadisplay/dataeditor.pyi": "35391d4ba147cf20ce4ac7a782066d61",
+  "reflex/components/datadisplay/dataeditor.pyi": "fb26f3e702fcb885539d1cf82a854be3",
   "reflex/components/datadisplay/shiki_code_block.pyi": "1d53e75b6be0d3385a342e7b3011babd",
   "reflex/components/el/__init__.pyi": "0adfd001a926a2a40aee94f6fa725ecc",
   "reflex/components/el/element.pyi": "c5974a92fbc310e42d0f6cfdd13472f4",

reflex/components/datadisplay/dataeditor.py

@@ -15,6 +15,7 @@
 from reflex.utils.serializers import serializer
 from reflex.vars import get_unique_variable_name
 from reflex.vars.base import Var
+from reflex.vars.function import FunctionStringVar
 from reflex.vars.sequence import ArrayVar
 
 
@@ -260,6 +261,12 @@ class DataEditor(NoSSRComponent):
     # Allow columns selections. ("none", "single", "multi")
     column_select: Var[Literal["none", "single", "multi"]]
 
+    # Allow range selections. ("none", "cell", "rect", "multi-cell", "multi-rect").
+    range_select: Var[Literal["none", "cell", "rect", "multi-cell", "multi-rect"]]
+
+    # Allow row selections. ("none", "single", "multi").
+    row_select: Var[Literal["none", "single", "multi"]]
+
     # Prevent diagonal scrolling.
     prevent_diagonal_scrolling: Var[bool]
 
@@ -275,6 +282,18 @@ class DataEditor(NoSSRComponent):
     # Initial scroll offset on the vertical axis.
     scroll_offset_y: Var[int]
 
+    # Controls which types of range selections can exist at the same time. ("exclusive", "mixed").
+    range_selection_blending: Var[Literal["exclusive", "mixed"]]
+
+    # Controls which types of column selections can exist at the same time. ("exclusive", "mixed").
+    column_selection_blending: Var[Literal["exclusive", "mixed"]]
+
+    # Controls which types of row selections can exist at the same time. ("exclusive", "mixed").
+    row_selection_blending: Var[Literal["exclusive", "mixed"]]
+
+    # Controls how spans are handled in selections. ("default", "allowPartial").
+    span_range_behavior: Var[Literal["default", "allowPartial"]]
+
     # global theme
     theme: Var[DataEditorTheme | dict]
 
@@ -326,6 +345,12 @@ class DataEditor(NoSSRComponent):
     # Fired when a row is appended.
     on_row_appended: EventHandler[no_args_event_spec]
 
+    # The current grid selection state (columns, rows, and current cell/range). Must be used when on_grid_selection_change is used otherwise updates will not be reflected in the grid.
+    grid_selection: Var[GridSelection]
+
+    # Fired when the grid selection changes. Will pass the current selection, the selected columns and the selected rows.
+    on_grid_selection_change: EventHandler[passthrough_event_spec(GridSelection)]
+
     # Fired when the selection is cleared.
     on_selection_cleared: EventHandler[no_args_event_spec]
 
@@ -342,12 +367,61 @@ def add_imports(self) -> ImportDict:
             return {}
         return {
             "": f"{format.format_library_name(self.library)}/dist/index.css",
-            self.library: "GridCellKind",
+            self.library: ["GridCellKind", "CompactSelection"],
             "$/utils/helpers/dataeditor.js": ImportVar(
                 tag="formatDataEditorCells", is_default=False, install=False
             ),
         }
 
+    def add_custom_code(self) -> list[str]:
+        """Add custom code for reconstructing GridSelection with CompactSelection objects.
+
+        Note: When using on_grid_selection_change, Glide Data Grid will not update its internal selection state automatically. Instead,
+        the grid_selection prop must be updated with a GridSelection object that has CompactSelection objects for the columns and rows properties.
+        This function provides the necessary JavaScript code to reconstruct the GridSelection object from a dict representation.
+
+        Returns:
+            JavaScript code to reconstruct GridSelection.
+        """
+        return [
+            """
+        function reconstructGridSelection(selection) {
+            if (!selection || typeof selection !== 'object') {
+                return undefined;
+            }
+
+            const reconstructCompactSelection = (data) => {
+                if (!data || !data.items || !Array.isArray(data.items)) {
+                    return CompactSelection.empty();
+                }
+
+                const items = data.items;
+                if (items.length === 0) {
+                    return CompactSelection.empty();
+                }
+
+                let result = CompactSelection.empty();
+
+                // Items are stored as [start, end) ranges in CompactSelection internal format
+                for (const item of items) {
+                    if (Array.isArray(item) && item.length === 2) {
+                        const [start, end] = item;
+                        result = result.add([start, end]);
+                    }
+                }
+
+                return result;
+            };
+
+            return {
+                current: selection.current || undefined,
+                columns: reconstructCompactSelection(selection.columns),
+                rows: reconstructCompactSelection(selection.rows)
+            };
+        }
+                    """
+        ]
+
     def add_hooks(self) -> list[str]:
         """Get the hooks to render.
 
@@ -429,6 +503,15 @@ def create(cls, *children, **props) -> Component:
             console.warn(
                 "get_cell_content is not user configurable, the provided value will be discarded"
             )
+
+        # Apply the reconstruction function to grid_selection if it's a Var
+        if (grid_selection := props.get("grid_selection")) is not None and isinstance(
+            grid_selection, Var
+        ):
+            props["grid_selection"] = FunctionStringVar.create(
+                "reconstructGridSelection"
+            ).call(grid_selection)
+
         grid = super().create(*children, **props)
         return Div.create(
             grid,

reflex/istate/proxy.py

@@ -508,8 +508,13 @@ def _wrap_recursive(self, value: Any) -> Any:
         # When called from dataclasses internal code, return the unwrapped value
         if self._is_called_from_dataclasses_internal():
             return value
-        # Recursively wrap mutable types, but do not re-wrap MutableProxy instances.
-        if is_mutable_type(type(value)) and not isinstance(value, MutableProxy):
+        # If we already have a proxy, make sure the state reference is up to date and return it.
+        if isinstance(value, MutableProxy):
+            if value._self_state is not self._self_state:
+                value._self_state = self._self_state
+            return value
+        # Recursively wrap mutable types.
+        if is_mutable_type(type(value)):
             base_cls = globals()[self.__base_proxy__]
             return base_cls(
                 wrapped=value,

reflex/istate/shared.py

@@ -348,10 +348,11 @@ async def _modify_linked_states(
                         linked_state_name
                     )
                 )
-                # TODO: Avoid always fetched linked states, it should be based on
-                # whether the state is accessed, however then `get_state` would need
-                # to know how to fetch in a linked state.
-                original_state = await self.get_state(linked_state_cls)
+                try:
+                    original_state = self._get_state_from_cache(linked_state_cls)
+                except ValueError:
+                    # This state wasn't required for processing the event.
+                    continue
                 linked_state = await original_state._internal_patch_linked_state(
                     linked_token
                 )
@@ -410,3 +411,9 @@ def __init_subclass__(cls, **kwargs):
         root_state = cls.get_root_state()
         if root_state.backend_vars["_reflex_internal_links"] is None:
             root_state.backend_vars["_reflex_internal_links"] = {}
+        if root_state is State:
+            # Always fetch SharedStateBaseInternal to access
+            # `_modify_linked_states` without having to use `.get_state()` which
+            # pulls in all linked states and substates which may not actually be
+            # accessed for this event.
+            root_state._always_dirty_substates.add(SharedStateBaseInternal.get_name())

reflex/state.py

@@ -2470,6 +2470,35 @@ class State(BaseState):
     # Maps the state full_name to an arbitrary token it is linked to for shared state.
     _reflex_internal_links: dict[str, str] | None = None
 
+    @_override_base_method
+    async def _get_state_from_redis(self, state_cls: type[T_STATE]) -> T_STATE:
+        """Get a state instance from redis with linking support.
+
+        Args:
+            state_cls: The class of the state.
+
+        Returns:
+            The instance of state_cls associated with this state's client_token.
+        """
+        state_instance = await super()._get_state_from_redis(state_cls)
+        if (
+            self._reflex_internal_links
+            and (
+                linked_token := self._reflex_internal_links.get(
+                    state_cls.get_full_name()
+                )
+            )
+            is not None
+            and (
+                internal_patch_linked_state := getattr(
+                    state_instance, "_internal_patch_linked_state", None
+                )
+            )
+            is not None
+        ):
+            return await internal_patch_linked_state(linked_token)
+        return state_instance
+
     @event
     def set_is_hydrated(self, value: bool) -> None:
         """Set the hydrated state.

reflex/utils/token_manager.py

@@ -4,12 +4,12 @@
 
 import asyncio
 import dataclasses
-import json
+import pickle
 import uuid
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Callable, Coroutine
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, ClassVar
 
 from reflex.istate.manager.redis import StateManagerRedis
 from reflex.state import BaseState, StateUpdate
@@ -42,7 +42,7 @@ class LostAndFoundRecord:
     """Record for a StateUpdate for a token with its socket on another instance."""
 
     token: str
-    update: dict[str, Any]
+    update: StateUpdate
 
 
 class TokenManager(ABC):
@@ -328,7 +328,7 @@ async def link_token_to_sid(self, token: str, sid: str) -> str | None:
         try:
             await self.redis.set(
                 redis_key,
-                json.dumps(dataclasses.asdict(socket_record)),
+                pickle.dumps(socket_record),
                 ex=self.token_expiration,
             )
         except Exception as e:
@@ -386,8 +386,8 @@ async def _subscribe_lost_and_found_updates(
             )
             async for message in pubsub.listen():
                 if message["type"] == "pmessage":
-                    record = LostAndFoundRecord(**json.loads(message["data"].decode()))
-                    await emit_update(StateUpdate(**record.update), record.token)
+                    record = pickle.loads(message["data"])
+                    await emit_update(record.update, record.token)
 
     def ensure_lost_and_found_task(
         self,
@@ -424,10 +424,9 @@ async def _get_token_owner(self, token: str, refresh: bool = False) -> str | Non
 
         redis_key = self._get_redis_key(token)
         try:
-            record_json = await self.redis.get(redis_key)
-            if record_json:
-                record_data = json.loads(record_json)
-                socket_record = SocketRecord(**record_data)
+            record_pkl = await self.redis.get(redis_key)
+            if record_pkl:
+                socket_record = pickle.loads(record_pkl)
                 self.token_to_socket[token] = socket_record
                 self.sid_to_token[socket_record.sid] = token
                 return socket_record.instance_id
@@ -454,11 +453,11 @@ async def emit_lost_and_found(
         owner_instance_id = await self._get_token_owner(token)
         if owner_instance_id is None:
             return False
-        record = LostAndFoundRecord(token=token, update=dataclasses.asdict(update))
+        record = LostAndFoundRecord(token=token, update=update)
         try:
             await self.redis.publish(
                 f"channel:{self._get_lost_and_found_key(owner_instance_id)}",
-                json.dumps(dataclasses.asdict(record)),
+                pickle.dumps(record),
             )
         except Exception as e:
             console.error(f"Redis error publishing lost and found delta: {e}")

reflex/vars/dep_tracking.py

@@ -179,7 +179,11 @@ def load_attr_or_method(self, instruction: dis.Instruction) -> None:
         if not self.top_of_stack:
             return
         target_obj = self.get_tracked_local(self.top_of_stack)
-        target_state = assert_base_state(target_obj, local_name=self.top_of_stack)
+        try:
+            target_state = assert_base_state(target_obj, local_name=self.top_of_stack)
+        except VarValueError:
+            # If the target state is not a BaseState, we cannot track dependencies on it.
+            return
         try:
             ref_obj = getattr(target_state, instruction.argval)
         except AttributeError:

tests/integration/test_connection_banner.py

@@ -1,5 +1,6 @@
 """Test case for displaying the connection banner when the websocket drops."""
 
+import pickle
 from collections.abc import Generator
 
 import pytest
@@ -10,7 +11,7 @@
 from reflex.environment import environment
 from reflex.istate.manager.redis import StateManagerRedis
 from reflex.testing import AppHarness, WebDriver
-from reflex.utils.token_manager import RedisTokenManager
+from reflex.utils.token_manager import RedisTokenManager, SocketRecord
 
 from .utils import SessionStorage
 
@@ -166,11 +167,10 @@ async def test_connection_banner(connection_banner: AppHarness):
     sid_before = app_token_manager.token_to_sid[token]
     if isinstance(connection_banner.state_manager, StateManagerRedis):
         assert isinstance(app_token_manager, RedisTokenManager)
-        assert (
-            await connection_banner.state_manager.redis.get(
-                app_token_manager._get_redis_key(token)
-            )
-            == f'{{"instance_id": "{app_token_manager.instance_id}", "sid": "{sid_before}"}}'.encode()
+        assert await connection_banner.state_manager.redis.get(
+            app_token_manager._get_redis_key(token)
+        ) == pickle.dumps(
+            SocketRecord(instance_id=app_token_manager.instance_id, sid=sid_before)
         )
 
     delay_button = driver.find_element(By.ID, "delay")
@@ -226,11 +226,10 @@ async def test_connection_banner(connection_banner: AppHarness):
     assert sid_before != sid_after
     if isinstance(connection_banner.state_manager, StateManagerRedis):
         assert isinstance(app_token_manager, RedisTokenManager)
-        assert (
-            await connection_banner.state_manager.redis.get(
-                app_token_manager._get_redis_key(token)
-            )
-            == f'{{"instance_id": "{app_token_manager.instance_id}", "sid": "{sid_after}"}}'.encode()
+        assert await connection_banner.state_manager.redis.get(
+            app_token_manager._get_redis_key(token)
+        ) == pickle.dumps(
+            SocketRecord(instance_id=app_token_manager.instance_id, sid=sid_after)
         )
 
     # Count should have incremented after coming back up