reflex 0.8.11a1__py3-none-any.whl → 0.8.12__py3-none-any.whl

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

@@ -478,8 +478,8 @@ export const queueEvents = async (
  * @param params The params object from React Router
  */
 export const processEvent = async (socket, navigate, params) => {
-  // Only proceed if the socket is up and no event in the queue uses state, otherwise we throw the event into the void
-  if (!socket && isStateful()) {
+  // Only proceed if the socket is up or no event in the queue uses state, otherwise we throw the event into the void
+  if (isStateful() && !(socket && socket.connected)) {
     return;
   }
 
@@ -531,6 +531,7 @@ export const connect = async (
 ) => {
   // Get backend URL object from the endpoint.
   const endpoint = getBackendURL(EVENTURL);
+  const on_hydrated_queue = [];
 
   // Create the socket.
   socket.current = io(endpoint.href, {
@@ -552,7 +553,17 @@ export const connect = async (
 
   function checkVisibility() {
     if (document.visibilityState === "visible") {
-      if (!socket.current.connected) {
+      if (!socket.current) {
+        connect(
+          socket,
+          dispatch,
+          transports,
+          setConnectErrors,
+          client_storage,
+          navigate,
+          params,
+        );
+      } else if (!socket.current.connected) {
         console.log("Socket is disconnected, attempting to reconnect ");
         socket.current.connect();
       } else {
@@ -576,11 +587,15 @@ export const connect = async (
   };
 
   // Once the socket is open, hydrate the page.
-  socket.current.on("connect", () => {
+  socket.current.on("connect", async () => {
     setConnectErrors([]);
     window.addEventListener("pagehide", pagehideHandler);
     window.addEventListener("beforeunload", disconnectTrigger);
     window.addEventListener("unload", disconnectTrigger);
+    // Drain any initial events from the queue.
+    while (event_queue.length > 0 && !event_processing) {
+      await processEvent(socket.current, navigate, () => params.current);
+    }
   });
 
   socket.current.on("connect_error", (error) => {
@@ -589,6 +604,7 @@ export const connect = async (
 
   // When the socket disconnects reset the event_processing flag
   socket.current.on("disconnect", () => {
+    socket.current = null; // allow reconnect to occur automatically
     event_processing = false;
     window.removeEventListener("unload", disconnectTrigger);
     window.removeEventListener("beforeunload", disconnectTrigger);
@@ -599,6 +615,14 @@ export const connect = async (
   socket.current.on("event", async (update) => {
     for (const substate in update.delta) {
       dispatch[substate](update.delta[substate]);
+      // handle events waiting for `is_hydrated`
+      if (
+        substate === state_name &&
+        update.delta[substate]?.is_hydrated_rx_state_
+      ) {
+        queueEvents(on_hydrated_queue, socket, false, navigate, params);
+        on_hydrated_queue.length = 0;
+      }
     }
     applyClientStorageDelta(client_storage, update.delta);
     event_processing = !update.final;
@@ -608,7 +632,8 @@ export const connect = async (
   });
   socket.current.on("reload", async (event) => {
     event_processing = false;
-    queueEvents([...initialEvents(), event], socket, true, navigate, params);
+    on_hydrated_queue.push(event);
+    queueEvents(initialEvents(), socket, true, navigate, params);
   });
   socket.current.on("new_token", async (new_token) => {
     token = new_token;
@@ -770,10 +795,32 @@ export const useEventLoop = (
     }
   }, [paramsR]);
 
+  const ensureSocketConnected = useCallback(async () => {
+    // only use websockets if state is present and backend is not disabled (reflex cloud).
+    if (
+      Object.keys(initialState).length > 1 &&
+      !isBackendDisabled() &&
+      !socket.current
+    ) {
+      // Initialize the websocket connection.
+      await connect(
+        socket,
+        dispatch,
+        ["websocket"],
+        setConnectErrors,
+        client_storage,
+        navigate,
+        () => params.current,
+      );
+    }
+  }, [socket, dispatch, setConnectErrors, client_storage, navigate, params]);
+
   // Function to add new events to the event queue.
   const addEvents = useCallback((events, args, event_actions) => {
     const _events = events.filter((e) => e !== undefined && e !== null);
 
+    ensureSocketConnected();
+
     if (!(args instanceof Array)) {
       args = [args];
     }
@@ -866,21 +913,8 @@ export const useEventLoop = (
 
   // Handle socket connect/disconnect.
   useEffect(() => {
-    // only use websockets if state is present and backend is not disabled (reflex cloud).
-    if (Object.keys(initialState).length > 1 && !isBackendDisabled()) {
-      // Initialize the websocket connection.
-      if (!socket.current) {
-        connect(
-          socket,
-          dispatch,
-          ["websocket"],
-          setConnectErrors,
-          client_storage,
-          navigate,
-          () => params.current,
-        );
-      }
-    }
+    // Initialize the websocket connection.
+    ensureSocketConnected();
 
     // Cleanup function.
     return () => {
@@ -893,12 +927,13 @@ export const useEventLoop = (
   // Main event loop.
   useEffect(() => {
     // Skip if the backend is disabled
-    if (isBackendDisabled()) {
+    if (isBackendDisabled() || !socket.current || !socket.current.connected) {
       return;
     }
     (async () => {
       // Process all outstanding events.
       while (event_queue.length > 0 && !event_processing) {
+        await ensureSocketConnected();
         await processEvent(socket.current, navigate, () => params.current);
       }
     })();

reflex/app.py

@@ -97,6 +97,7 @@ from reflex.state import (
     State,
     StateManager,
     StateUpdate,
+    _split_substate_key,
     _substate_key,
     all_base_state_classes,
     code_uses_state_contexts,
@@ -1559,7 +1560,7 @@ class App(MiddlewareMixin, LifespanMixin):
                 state._clean()
                 await self.event_namespace.emit_update(
                     update=StateUpdate(delta=delta),
-                    sid=state.router.session.session_id,
+                    token=token,
                 )
 
     def _process_background(
@@ -1599,7 +1600,7 @@ class App(MiddlewareMixin, LifespanMixin):
                 # Send the update to the client.
                 await self.event_namespace.emit_update(
                     update=update,
-                    sid=state.router.session.session_id,
+                    token=event.token,
                 )
 
         task = asyncio.create_task(
@@ -2061,20 +2062,19 @@ class EventNamespace(AsyncNamespace):
                 and console.error(f"Token cleanup error: {t.exception()}")
             )
 
-    async def emit_update(self, update: StateUpdate, sid: str) -> None:
+    async def emit_update(self, update: StateUpdate, token: str) -> None:
         """Emit an update to the client.
 
         Args:
             update: The state update to send.
-            sid: The Socket.IO session id.
+            token: The client token (tab) associated with the event.
         """
-        if not sid:
+        client_token, _ = _split_substate_key(token)
+        sid = self.token_to_sid.get(client_token)
+        if sid is None:
             # If the sid is None, we are not connected to a client. Prevent sending
             # updates to all clients.
-            return
-        token = self.sid_to_token.get(sid)
-        if token is None:
-            console.warn(f"Attempting to send delta to disconnected websocket {sid}")
+            console.warn(f"Attempting to send delta to disconnected client {token!r}")
             return
         # Creating a task prevents the update from being blocked behind other coroutines.
         await asyncio.create_task(
@@ -2165,7 +2165,7 @@ class EventNamespace(AsyncNamespace):
             # Process the events.
             async for update in updates_gen:
                 # Emit the update from processing the event.
-                await self.emit_update(update=update, sid=sid)
+                await self.emit_update(update=update, token=event.token)
 
     async def on_ping(self, sid: str):
         """Event for testing the API endpoint.
@@ -2189,3 +2189,10 @@ class EventNamespace(AsyncNamespace):
         if new_token:
             # Duplicate detected, emit new token to client
             await self.emit("new_token", new_token, to=sid)
+
+        # Update client state to apply new sid/token for running background tasks.
+        async with self.app.modify_state(
+            _substate_key(new_token or token, self.app.state_manager.state)
+        ) as state:
+            state.router_data[constants.RouteVar.SESSION_ID] = sid
+            state.router = RouterData.from_router_data(state.router_data)

reflex/app_mixins/lifespan.py

@@ -60,6 +60,17 @@ class LifespanMixin(AppMixin):
             for task in running_tasks:
                 console.debug(f"Canceling lifespan task: {task}")
                 task.cancel(msg="lifespan_cleanup")
+        # Disassociate sid / token pairings so they can be reconnected properly.
+        try:
+            event_namespace = self.event_namespace  # pyright: ignore[reportAttributeAccessIssue]
+        except AttributeError:
+            pass
+        else:
+            try:
+                if event_namespace:
+                    await event_namespace._token_manager.disconnect_all()
+            except Exception as e:
+                console.error(f"Error during lifespan cleanup: {e}")
 
     def register_lifespan_task(self, task: Callable | asyncio.Task, **task_kwargs):
         """Register a task to run during the lifespan of the app.

reflex/compiler/compiler.py

@@ -621,7 +621,10 @@ def purge_web_pages_dir():
         return
 
     # Empty out the web pages directory.
-    utils.empty_dir(get_web_dir() / constants.Dirs.PAGES, keep_files=["routes.js"])
+    utils.empty_dir(
+        get_web_dir() / constants.Dirs.PAGES,
+        keep_files=["routes.js", "entry.client.js"],
+    )
 
 
 if TYPE_CHECKING:

reflex/compiler/templates.py

@@ -86,7 +86,7 @@ class _RenderUtils:
         children_rendered = "".join(
             [_RenderUtils.render(child) for child in component.get("children", [])]
         )
-        return f"{component['iterable_state']}.map(({component['arg_name']},{component['arg_index']})=>({children_rendered}))"
+        return f"Array.prototype.map.call({component['iterable_state']} ?? [],(({component['arg_name']},{component['arg_index']})=>({children_rendered})))"
 
     @staticmethod
     def render_match_tag(component: Any) -> str:

reflex/components/core/upload.py

@@ -17,6 +17,7 @@ from reflex.components.component import (
 from reflex.components.core.cond import cond
 from reflex.components.el.elements.forms import Input
 from reflex.components.radix.themes.layout.box import Box
+from reflex.components.sonner.toast import toast
 from reflex.constants import Dirs
 from reflex.constants.compiler import Hooks, Imports
 from reflex.environment import environment
@@ -36,7 +37,8 @@ from reflex.utils.imports import ImportVar
 from reflex.vars import VarData
 from reflex.vars.base import Var, get_unique_variable_name
 from reflex.vars.function import FunctionVar
-from reflex.vars.sequence import LiteralStringVar
+from reflex.vars.object import ObjectVar
+from reflex.vars.sequence import ArrayVar, LiteralStringVar
 
 DEFAULT_UPLOAD_ID: str = "default"
 
@@ -178,6 +180,34 @@ def _on_drop_spec(files: Var) -> tuple[Var[Any]]:
     return (files,)
 
 
+def _default_drop_rejected(rejected_files: ArrayVar[list[dict[str, Any]]]) -> EventSpec:
+    """Event handler for showing a toast with rejected file info.
+
+    Args:
+        rejected_files: The files that were rejected.
+
+    Returns:
+        An event spec that shows a toast with the rejected file info when triggered.
+    """
+
+    def _format_rejected_file_record(rf: ObjectVar[dict[str, Any]]) -> str:
+        rf = rf.to(ObjectVar, dict[str, dict[str, Any]])
+        file = rf["file"].to(ObjectVar, dict[str, Any])
+        errors = rf["errors"].to(ArrayVar, list[dict[str, Any]])
+        return (
+            f"{file['path']}: {errors.foreach(lambda err: err['message']).join(', ')}"
+        )
+
+    return toast.error(
+        title="Files not Accepted",
+        description=rejected_files.to(ArrayVar)
+        .foreach(_format_rejected_file_record)
+        .join("\n\n"),
+        close_button=True,
+        style={"white_space": "pre-line"},
+    )
+
+
 class UploadFilesProvider(Component):
     """AppWrap component that provides a dict of selected files by ID via useContext."""
 
@@ -191,6 +221,9 @@ class GhostUpload(Fragment):
     # Fired when files are dropped.
     on_drop: EventHandler[_on_drop_spec]
 
+    # Fired when dropped files do not meet the specified criteria.
+    on_drop_rejected: EventHandler[_on_drop_spec]
+
 
 class Upload(MemoizationLeaf):
     """A file upload component."""
@@ -234,6 +267,9 @@ class Upload(MemoizationLeaf):
     # Fired when files are dropped.
     on_drop: EventHandler[_on_drop_spec]
 
+    # Fired when dropped files do not meet the specified criteria.
+    on_drop_rejected: EventHandler[_on_drop_spec]
+
     # Style rules to apply when actively dragging.
     drag_active_style: Style | None = field(default=None, is_javascript_property=False)
 
@@ -295,6 +331,10 @@ class Upload(MemoizationLeaf):
                 on_drop[ix] = event
             upload_props["on_drop"] = on_drop
 
+        if upload_props.get("on_drop_rejected") is None:
+            # If on_drop_rejected is not provided, show an error toast.
+            upload_props["on_drop_rejected"] = _default_drop_rejected
+
         input_props_unique_name = get_unique_variable_name()
         root_props_unique_name = get_unique_variable_name()
         is_drag_active_unique_name = get_unique_variable_name()
@@ -313,22 +353,22 @@ class Upload(MemoizationLeaf):
                 ),
             )
 
-        event_var, callback_str = StatefulComponent._get_memoized_event_triggers(
-            GhostUpload.create(on_drop=upload_props["on_drop"])
-        )["on_drop"]
-
-        upload_props["on_drop"] = event_var
+        event_triggers = StatefulComponent._get_memoized_event_triggers(
+            GhostUpload.create(
+                on_drop=upload_props["on_drop"],
+                on_drop_rejected=upload_props["on_drop_rejected"],
+            )
+        )
+        callback_hooks = []
+        for trigger_name, (event_var, callback_str) in event_triggers.items():
+            upload_props[trigger_name] = event_var
+            callback_hooks.append(callback_str)
 
         upload_props = {
             format.to_camel_case(key): value for key, value in upload_props.items()
         }
 
-        use_dropzone_arguments = Var.create(
-            {
-                "onDrop": event_var,
-                **upload_props,
-            }
-        )
+        use_dropzone_arguments = Var.create(upload_props)
 
         left_side = (
             "const { "
@@ -344,11 +384,10 @@ class Upload(MemoizationLeaf):
                 imports=Imports.EVENTS,
                 hooks={Hooks.EVENTS: None},
             ),
-            event_var._get_all_var_data(),
             use_dropzone_arguments._get_all_var_data(),
             VarData(
                 hooks={
-                    callback_str: None,
+                    **dict.fromkeys(callback_hooks, None),
                     f"{left_side} = {right_side};": None,
                 },
                 imports={

reflex/components/core/upload.pyi

@@ -108,6 +108,7 @@ class GhostUpload(Fragment):
         on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_drop: EventType[()] | EventType[Any] | None = None,
+        on_drop_rejected: EventType[()] | EventType[Any] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -127,6 +128,7 @@ class GhostUpload(Fragment):
         Args:
             *children: The children of the component.
             on_drop: Fired when files are dropped.
+            on_drop_rejected: Fired when dropped files do not meet the specified criteria.
             style: The style of the component.
             key: A unique key for the component.
             id: The id for the component.
@@ -171,6 +173,7 @@ class Upload(MemoizationLeaf):
         on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_drop: EventType[()] | EventType[Any] | None = None,
+        on_drop_rejected: EventType[()] | EventType[Any] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -199,6 +202,7 @@ class Upload(MemoizationLeaf):
             no_drag: Whether to disable drag and drop.
             no_keyboard: Whether to disable using the space/enter keys to upload.
             on_drop: Fired when files are dropped.
+            on_drop_rejected: Fired when dropped files do not meet the specified criteria.
             drag_active_style: Style rules to apply when actively dragging.
             style: The style of the component.
             key: A unique key for the component.
@@ -242,6 +246,7 @@ class StyledUpload(Upload):
         on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_drop: EventType[()] | EventType[Any] | None = None,
+        on_drop_rejected: EventType[()] | EventType[Any] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -270,6 +275,7 @@ class StyledUpload(Upload):
             no_drag: Whether to disable drag and drop.
             no_keyboard: Whether to disable using the space/enter keys to upload.
             on_drop: Fired when files are dropped.
+            on_drop_rejected: Fired when dropped files do not meet the specified criteria.
             drag_active_style: Style rules to apply when actively dragging.
             style: The style of the component.
             key: A unique key for the component.
@@ -314,6 +320,7 @@ class UploadNamespace(ComponentNamespace):
         on_context_menu: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_double_click: EventType[()] | EventType[PointerEventInfo] | None = None,
         on_drop: EventType[()] | EventType[Any] | None = None,
+        on_drop_rejected: EventType[()] | EventType[Any] | None = None,
         on_focus: EventType[()] | None = None,
         on_mount: EventType[()] | None = None,
         on_mouse_down: EventType[()] | None = None,
@@ -342,6 +349,7 @@ class UploadNamespace(ComponentNamespace):
             no_drag: Whether to disable drag and drop.
             no_keyboard: Whether to disable using the space/enter keys to upload.
             on_drop: Fired when files are dropped.
+            on_drop_rejected: Fired when dropped files do not meet the specified criteria.
             drag_active_style: Style rules to apply when actively dragging.
             style: The style of the component.
             key: A unique key for the component.

reflex/components/lucide/icon.py

@@ -6,7 +6,7 @@ from reflex.utils.imports import ImportVar
 from reflex.vars.base import LiteralVar, Var
 from reflex.vars.sequence import LiteralStringVar, StringVar
 
-LUCIDE_LIBRARY = "lucide-react@0.543.0"
+LUCIDE_LIBRARY = "lucide-react@0.544.0"
 
 
 class LucideIconComponent(Component):
@@ -674,6 +674,7 @@ LUCIDE_ICON_LIST = [
     "eraser",
     "ethernet_port",
     "euro",
+    "ev_charger",
     "expand",
     "external_link",
     "eye_closed",

reflex/components/lucide/icon.pyi

@@ -11,7 +11,7 @@ from reflex.components.core.breakpoints import Breakpoints
 from reflex.event import EventType, PointerEventInfo
 from reflex.vars.base import Var
 
-LUCIDE_LIBRARY = "lucide-react@0.543.0"
+LUCIDE_LIBRARY = "lucide-react@0.544.0"
 
 class LucideIconComponent(Component):
     @classmethod
@@ -739,6 +739,7 @@ LUCIDE_ICON_LIST = [
     "eraser",
     "ethernet_port",
     "euro",
+    "ev_charger",
     "expand",
     "external_link",
     "eye_closed",

reflex/constants/installer.py

@@ -14,7 +14,7 @@ class Bun(SimpleNamespace):
     """Bun constants."""
 
     # The Bun version.
-    VERSION = "1.2.21"
+    VERSION = "1.2.22"
 
     # Min Bun Version
     MIN_VERSION = "1.2.17"
@@ -75,7 +75,7 @@ fetch-retries=0
 
 
 def _determine_react_router_version() -> str:
-    default_version = "7.8.2"
+    default_version = "7.9.1"
     if (version := os.getenv("REACT_ROUTER_VERSION")) and version != default_version:
         from reflex.utils import console
 
@@ -143,11 +143,11 @@ class PackageJson(SimpleNamespace):
         "postcss-import": "16.1.1",
         "@react-router/dev": _react_router_version,
         "@react-router/fs-routes": _react_router_version,
-        "vite": "npm:rolldown-vite@7.1.8",
+        "vite": "npm:rolldown-vite@7.1.9",
     }
     OVERRIDES = {
         # This should always match the `react` version in DEPENDENCIES for recharts compatibility.
         "react-is": _react_version,
         "cookie": "1.0.2",
-        "vite": "npm:rolldown-vite@7.1.8",
+        "vite": "npm:rolldown-vite@7.1.9",
     }

reflex/event.py

@@ -1782,7 +1782,7 @@ def call_event_fn(
     from reflex.event import EventHandler, EventSpec
     from reflex.utils.exceptions import EventHandlerValueError
 
-    parsed_args, event_annotations = parse_args_spec(arg_spec)
+    parsed_args, _ = parse_args_spec(arg_spec)
 
     parameters = inspect.signature(fn).parameters
 

reflex/istate/manager.py

@@ -355,7 +355,7 @@ class StateManagerDisk(StateManager):
             token: The token to set the state for.
             state: The state to set.
         """
-        client_token, substate = _split_substate_key(token)
+        client_token, _ = _split_substate_key(token)
         await self.set_state_for_substate(client_token, state)
 
     @override
@@ -370,7 +370,7 @@ class StateManagerDisk(StateManager):
             The state for the token.
         """
         # Memory state manager ignores the substate suffix and always returns the top-level state.
-        client_token, substate = _split_substate_key(token)
+        client_token, _ = _split_substate_key(token)
         if client_token not in self._states_locks:
             async with self._state_manager_lock:
                 if client_token not in self._states_locks:

reflex/istate/proxy.py

@@ -71,10 +71,15 @@ class StateProxy(wrapt.ObjectProxy):
             state_instance: The state instance to proxy.
             parent_state_proxy: The parent state proxy, for linked mutability and context tracking.
         """
+        from reflex.state import _substate_key
+
         super().__init__(state_instance)
-        # compile is not relevant to backend logic
         self._self_app = prerequisites.get_and_validate_app().app
         self._self_substate_path = tuple(state_instance.get_full_name().split("."))
+        self._self_substate_token = _substate_key(
+            state_instance.router.session.client_token,
+            self._self_substate_path,
+        )
         self._self_actx = None
         self._self_mutable = False
         self._self_actx_lock = asyncio.Lock()
@@ -127,16 +132,9 @@ class StateProxy(wrapt.ObjectProxy):
             msg = "The state is already mutable. Do not nest `async with self` blocks."
             raise ImmutableStateError(msg)
 
-        from reflex.state import _substate_key
-
         await self._self_actx_lock.acquire()
         self._self_actx_lock_holder = current_task
-        self._self_actx = self._self_app.modify_state(
-            token=_substate_key(
-                self.__wrapped__.router.session.client_token,
-                self._self_substate_path,
-            )
-        )
+        self._self_actx = self._self_app.modify_state(token=self._self_substate_token)
         mutable_state = await self._self_actx.__aenter__()
         super().__setattr__(
             "__wrapped__", mutable_state.get_substate(self._self_substate_path)
@@ -378,17 +376,6 @@ class MutableProxy(wrapt.ObjectProxy):
         pydantic.BaseModel.__dict__
     )
 
-    # These types will be wrapped in MutableProxy
-    __mutable_types__ = (
-        list,
-        dict,
-        set,
-        Base,
-        DeclarativeBase,
-        BaseModelV2,
-        BaseModelV1,
-    )
-
     # Dynamically generated classes for tracking dataclass mutations.
     __dataclass_proxies__: dict[type, type] = {}
 
@@ -469,20 +456,6 @@ class MutableProxy(wrapt.ObjectProxy):
             return wrapped(*args, **(kwargs or {}))
         return None
 
-    @classmethod
-    def _is_mutable_type(cls, value: Any) -> bool:
-        """Check if a value is of a mutable type and should be wrapped.
-
-        Args:
-            value: The value to check.
-
-        Returns:
-            Whether the value is of a mutable type.
-        """
-        return isinstance(value, cls.__mutable_types__) or (
-            dataclasses.is_dataclass(value) and not isinstance(value, Var)
-        )
-
     @staticmethod
     def _is_called_from_dataclasses_internal() -> bool:
         """Check if the current function is called from dataclasses helper.
@@ -514,7 +487,7 @@ class MutableProxy(wrapt.ObjectProxy):
         if self._is_called_from_dataclasses_internal():
             return value
         # Recursively wrap mutable types, but do not re-wrap MutableProxy instances.
-        if self._is_mutable_type(value) and not isinstance(value, MutableProxy):
+        if is_mutable_type(type(value)) and not isinstance(value, MutableProxy):
             base_cls = globals()[self.__base_proxy__]
             return base_cls(
                 wrapped=value,
@@ -575,7 +548,7 @@ class MutableProxy(wrapt.ObjectProxy):
                     self._wrap_recursive_decorator,
                 )
 
-        if self._is_mutable_type(value) and __name not in (
+        if is_mutable_type(type(value)) and __name not in (
             "__wrapped__",
             "_self_state",
             "__dict__",
@@ -764,3 +737,30 @@ class ImmutableMutableProxy(MutableProxy):
         return super()._mark_dirty(
             wrapped=wrapped, instance=instance, args=args, kwargs=kwargs
         )
+
+
+# These types will be wrapped in MutableProxy
+MUTABLE_TYPES = (
+    list,
+    dict,
+    set,
+    Base,
+    DeclarativeBase,
+    BaseModelV2,
+    BaseModelV1,
+)
+
+
+@functools.lru_cache(maxsize=1024)
+def is_mutable_type(type_: type) -> bool:
+    """Check if a type is mutable and should be wrapped.
+
+    Args:
+        type_: The type to check.
+
+    Returns:
+        Whether the type is mutable and should be wrapped.
+    """
+    return issubclass(type_, MUTABLE_TYPES) or (
+        dataclasses.is_dataclass(type_) and not issubclass(type_, Var)
+    )