reflex 0.8.15a1__py3-none-any.whl → 0.8.16a1__py3-none-any.whl

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

@@ -529,6 +529,14 @@ export const connect = async (
   navigate,
   params,
 ) => {
+  // Socket already allocated, just reconnect it if needed.
+  if (socket.current) {
+    if (!socket.current.connected) {
+      socket.current.reconnect();
+    }
+    return;
+  }
+
   // Get backend URL object from the endpoint.
   const endpoint = getBackendURL(EVENTURL);
   const on_hydrated_queue = [];
@@ -540,7 +548,9 @@ export const connect = async (
     protocols: [reflexEnvironment.version],
     autoUnref: false,
     query: { token: getToken() },
+    reconnection: false, // Reconnection will be handled manually.
   });
+  socket.current.wait_connect = !socket.current.connected;
   // Ensure undefined fields in events are sent as null instead of removed
   socket.current.io.encoder.replacer = (k, v) => (v === undefined ? null : v);
   socket.current.io.decoder.tryParse = (str) => {
@@ -550,6 +560,18 @@ export const connect = async (
       return false;
     }
   };
+  // Set up a reconnect helper function
+  socket.current.reconnect = () => {
+    if (
+      socket.current &&
+      !socket.current.connected &&
+      !socket.current.wait_connect
+    ) {
+      socket.current.wait_connect = true;
+      socket.current.io.opts.query = { token: getToken() }; // Update token for reconnect.
+      socket.current.connect();
+    }
+  };
 
   function checkVisibility() {
     if (document.visibilityState === "visible") {
@@ -565,7 +587,7 @@ export const connect = async (
         );
       } else if (!socket.current.connected) {
         console.log("Socket is disconnected, attempting to reconnect ");
-        socket.current.connect();
+        socket.current.reconnect();
       } else {
         console.log("Socket is reconnected ");
       }
@@ -588,6 +610,7 @@ export const connect = async (
 
   // Once the socket is open, hydrate the page.
   socket.current.on("connect", async () => {
+    socket.current.wait_connect = false;
     setConnectErrors([]);
     window.addEventListener("pagehide", pagehideHandler);
     window.addEventListener("beforeunload", disconnectTrigger);
@@ -599,16 +622,33 @@ export const connect = async (
   });
 
   socket.current.on("connect_error", (error) => {
-    setConnectErrors((connectErrors) => [connectErrors.slice(-9), error]);
+    socket.current.wait_connect = false;
+    let n_connect_errors = 0;
+    setConnectErrors((connectErrors) => {
+      const new_errors = [...connectErrors.slice(-9), error];
+      n_connect_errors = new_errors.length;
+      return new_errors;
+    });
+    window.setTimeout(() => {
+      if (socket.current && !socket.current.connected) {
+        socket.current.reconnect();
+      }
+    }, 200 * n_connect_errors); // Incremental backoff
   });
 
   // When the socket disconnects reset the event_processing flag
-  socket.current.on("disconnect", () => {
-    socket.current = null; // allow reconnect to occur automatically
+  socket.current.on("disconnect", (reason, details) => {
+    socket.current.wait_connect = false;
+    const try_reconnect =
+      reason !== "io server disconnect" && reason !== "io client disconnect";
     event_processing = false;
     window.removeEventListener("unload", disconnectTrigger);
     window.removeEventListener("beforeunload", disconnectTrigger);
     window.removeEventListener("pagehide", pagehideHandler);
+    if (try_reconnect) {
+      // Attempt to reconnect transient non-intentional disconnects.
+      socket.current.reconnect();
+    }
   });
 
   // On each received message, queue the updates and events.
@@ -785,6 +825,7 @@ export const useEventLoop = (
   const [searchParams] = useSearchParams();
   const [connectErrors, setConnectErrors] = useState([]);
   const params = useRef(paramsR);
+  const mounted = useRef(false);
 
   useEffect(() => {
     const { "*": splat, ...remainingParams } = paramsR;
@@ -796,11 +837,16 @@ export const useEventLoop = (
   }, [paramsR]);
 
   const ensureSocketConnected = useCallback(async () => {
+    if (!mounted.current) {
+      // During hot reload, some components may still have a reference to
+      // addEvents, so avoid reconnecting the socket of an unmounted event loop.
+      return;
+    }
     // only use websockets if state is present and backend is not disabled (reflex cloud).
     if (
       Object.keys(initialState).length > 1 &&
       !isBackendDisabled() &&
-      !socket.current
+      !socket.current?.connected
     ) {
       // Initialize the websocket connection.
       await connect(
@@ -813,13 +859,23 @@ export const useEventLoop = (
         () => params.current,
       );
     }
-  }, [socket, dispatch, setConnectErrors, client_storage, navigate, params]);
+  }, [
+    socket,
+    dispatch,
+    setConnectErrors,
+    client_storage,
+    navigate,
+    params,
+    mounted,
+  ]);
 
   // 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 (!event_actions?.temporal) {
+      // Reconnect socket if needed for non-temporal events.
+      ensureSocketConnected();
+    }
 
     if (!(args instanceof Array)) {
       args = [args];
@@ -914,12 +970,16 @@ export const useEventLoop = (
   // Handle socket connect/disconnect.
   useEffect(() => {
     // Initialize the websocket connection.
+    mounted.current = true;
     ensureSocketConnected();
 
     // Cleanup function.
     return () => {
+      mounted.current = false;
       if (socket.current) {
         socket.current.disconnect();
+        socket.current.off();
+        socket.current = null;
       }
     };
   }, []);

reflex/app.py

@@ -11,6 +11,7 @@ import functools
 import inspect
 import io
 import json
+import operator
 import sys
 import time
 import traceback
@@ -118,6 +119,7 @@ from reflex.utils.exec import (
     should_prerender_routes,
 )
 from reflex.utils.imports import ImportVar
+from reflex.utils.misc import run_in_thread
 from reflex.utils.token_manager import TokenManager
 from reflex.utils.types import ASGIApp, Message, Receive, Scope, Send
 
@@ -849,7 +851,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
         # Setup dynamic args for the route.
         # this state assignment is only required for tests using the deprecated state kwarg for App
-        state = self._state if self._state else State
+        state = self._state or State
         state.setup_dynamic_args(get_route_args(route))
 
         self._load_events[route] = (
@@ -969,14 +971,10 @@ class App(MiddlewareMixin, LifespanMixin):
 
         if admin_dash and admin_dash.models:
             # Build the admin dashboard
-            admin = (
-                admin_dash.admin
-                if admin_dash.admin
-                else Admin(
-                    engine=Model.get_db_engine(),
-                    title="Reflex Admin Dashboard",
-                    logo_url="https://reflex.dev/Reflex.svg",
-                )
+            admin = admin_dash.admin or Admin(
+                engine=Model.get_db_engine(),
+                title="Reflex Admin Dashboard",
+                logo_url="https://reflex.dev/Reflex.svg",
             )
 
             for model in admin_dash.models:
@@ -1009,21 +1007,21 @@ class App(MiddlewareMixin, LifespanMixin):
         page_imports = {i for i in page_imports if i not in pinned}
 
         frontend_packages = get_config().frontend_packages
-        _frontend_packages = []
+        filtered_frontend_packages = []
         for package in frontend_packages:
             if package in page_imports:
                 console.warn(
                     f"React packages and their dependencies are inferred from Component.library and Component.lib_dependencies, remove `{package}` from `frontend_packages`"
                 )
                 continue
-            _frontend_packages.append(package)
-        page_imports.update(_frontend_packages)
+            filtered_frontend_packages.append(package)
+        page_imports.update(filtered_frontend_packages)
         js_runtimes.install_frontend_packages(page_imports, get_config())
 
     def _app_root(self, app_wrappers: dict[tuple[int, str], Component]) -> Component:
         for component in tuple(app_wrappers.values()):
             app_wrappers.update(component._get_all_app_wrap_components())
-        order = sorted(app_wrappers, key=lambda k: k[0], reverse=True)
+        order = sorted(app_wrappers, key=operator.itemgetter(0), reverse=True)
         root = copy.deepcopy(app_wrappers[order[0]])
 
         def reducer(parent: Component, key: tuple[int, str]) -> Component:
@@ -1095,7 +1093,7 @@ class App(MiddlewareMixin, LifespanMixin):
             sticky_badge._add_style_recursive({})
             return sticky_badge
 
-        self.app_wraps[(0, "StickyBadge")] = lambda _: memoized_badge()
+        self.app_wraps[0, "StickyBadge"] = lambda _: memoized_badge()
 
     def _apply_decorated_pages(self):
         """Add @rx.page decorated pages to the app."""
@@ -1190,13 +1188,13 @@ class App(MiddlewareMixin, LifespanMixin):
 
         if self.theme is not None:
             # If a theme component was provided, wrap the app with it
-            app_wrappers[(20, "Theme")] = self.theme
+            app_wrappers[20, "Theme"] = self.theme
 
         # Get the env mode.
         config = get_config()
 
         if config.react_strict_mode:
-            app_wrappers[(200, "StrictMode")] = StrictMode.create()
+            app_wrappers[200, "StrictMode"] = StrictMode.create()
 
         if not should_compile and not dry_run:
             with console.timing("Evaluate Pages (Backend)"):
@@ -1251,7 +1249,7 @@ class App(MiddlewareMixin, LifespanMixin):
                 + "\n".join(
                     f"{route}: {time * 1000:.1f}ms"
                     for route, time in sorted(
-                        performance_metrics, key=lambda x: x[1], reverse=True
+                        performance_metrics, key=operator.itemgetter(1), reverse=True
                     )[:10]
                 )
             )
@@ -1295,7 +1293,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
             toast_provider = Fragment.create(memoized_toast_provider())
 
-            app_wrappers[(44, "ToasterProvider")] = toast_provider
+            app_wrappers[44, "ToasterProvider"] = toast_provider
 
         # Add the app wraps to the app.
         for key, app_wrap in chain(
@@ -1427,12 +1425,10 @@ class App(MiddlewareMixin, LifespanMixin):
                 plugin.pre_compile(
                     add_save_task=_submit_work_without_advancing,
                     add_modify_task=(
-                        lambda *args, plugin=plugin: modify_files_tasks.append(
-                            (
-                                plugin.__class__.__module__ + plugin.__class__.__name__,
-                                *args,
-                            )
-                        )
+                        lambda *args, plugin=plugin: modify_files_tasks.append((
+                            plugin.__class__.__module__ + plugin.__class__.__name__,
+                            *args,
+                        ))
                     ),
                     unevaluated_pages=list(self._unevaluated_pages.values()),
                 )
@@ -1552,7 +1548,7 @@ class App(MiddlewareMixin, LifespanMixin):
         if not self._api:
             return
 
-        async def all_routes(_request: Request) -> Response:
+        def all_routes(_request: Request) -> Response:
             return JSONResponse(list(self._unevaluated_pages.keys()))
 
         self._api.add_route(
@@ -1663,21 +1659,21 @@ class App(MiddlewareMixin, LifespanMixin):
             strict=True,
         ):
             if hasattr(handler_fn, "__name__"):
-                _fn_name = handler_fn.__name__
+                fn_name_ = handler_fn.__name__
             else:
-                _fn_name = type(handler_fn).__name__
+                fn_name_ = type(handler_fn).__name__
 
             if isinstance(handler_fn, functools.partial):
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is a partial function. Please provide a named function instead."
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is a partial function. Please provide a named function instead."
                 raise ValueError(msg)
 
             if not callable(handler_fn):
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is not a function."
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is not a function."
                 raise ValueError(msg)
 
             # Allow named functions only as lambda functions cannot be introspected
-            if _fn_name == "<lambda>":
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is a lambda function. Please use a named function instead."
+            if fn_name_ == "<lambda>":
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is a lambda function. Please use a named function instead."
                 raise ValueError(msg)
 
             # Check if the function has the necessary annotations and types in the right order
@@ -1690,18 +1686,18 @@ class App(MiddlewareMixin, LifespanMixin):
 
             for required_arg_index, required_arg in enumerate(handler_spec):
                 if required_arg not in arg_annotations:
-                    msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` does not take the required argument `{required_arg}`"
+                    msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` does not take the required argument `{required_arg}`"
                     raise ValueError(msg)
                 if list(arg_annotations.keys())[required_arg_index] != required_arg:
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong argument order."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong argument order."
                         f"Expected `{required_arg}` as the {required_arg_index + 1} argument but got `{list(arg_annotations.keys())[required_arg_index]}`"
                     )
                     raise ValueError(msg)
 
                 if not issubclass(arg_annotations[required_arg], Exception):
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong type for {required_arg} argument."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong type for {required_arg} argument."
                         f"Expected to be `Exception` but got `{arg_annotations[required_arg]}`"
                     )
                     raise ValueError(msg)
@@ -1725,7 +1721,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
                 if not valid:
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong return type."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong return type."
                         f"Expected `EventSpec | list[EventSpec] | None` but got `{return_type}`"
                     )
                     raise ValueError(msg)
@@ -1754,15 +1750,13 @@ async def process(
     try:
         # Add request data to the state.
         router_data = event.router_data
-        router_data.update(
-            {
-                constants.RouteVar.QUERY: format.format_query_params(event.router_data),
-                constants.RouteVar.CLIENT_TOKEN: event.token,
-                constants.RouteVar.SESSION_ID: sid,
-                constants.RouteVar.HEADERS: headers,
-                constants.RouteVar.CLIENT_IP: client_ip,
-            }
-        )
+        router_data.update({
+            constants.RouteVar.QUERY: format.format_query_params(event.router_data),
+            constants.RouteVar.CLIENT_TOKEN: event.token,
+            constants.RouteVar.SESSION_ID: sid,
+            constants.RouteVar.HEADERS: headers,
+            constants.RouteVar.CLIENT_IP: client_ip,
+        })
         # Get the state for the session exclusively.
         async with app.state_manager.modify_state(event.substate_token) as state:
             # When this is a brand new instance of the state, signal the
@@ -1781,16 +1775,16 @@ async def process(
                     name=f"reflex_emit_reload|{event.name}|{time.time()}|{event.token}",
                 )
                 return
+            router_data[constants.RouteVar.PATH] = "/" + (
+                app.router(path) or "404"
+                if (path := router_data.get(constants.RouteVar.PATH))
+                else "404"
+            ).removeprefix("/")
             # re-assign only when the value is different
             if state.router_data != router_data:
                 # assignment will recurse into substates and force recalculation of
                 # dependent ComputedVar (dynamic route variables)
                 state.router_data = router_data
-                router_data[constants.RouteVar.PATH] = "/" + (
-                    app.router(path) or "404"
-                    if (path := router_data.get(constants.RouteVar.PATH))
-                    else "404"
-                ).removeprefix("/")
                 state.router = RouterData.from_router_data(router_data)
 
             # Preprocess the event.
@@ -1820,7 +1814,7 @@ async def process(
         raise
 
 
-async def ping(_request: Request) -> Response:
+def ping(_request: Request) -> Response:
     """Test API endpoint.
 
     Args:
@@ -1852,7 +1846,7 @@ async def health(_request: Request) -> JSONResponse:
     if prerequisites.check_db_used():
         from reflex.model import get_db_status
 
-        tasks.append(get_db_status())
+        tasks.append(run_in_thread(get_db_status))
     if prerequisites.check_redis_used():
         tasks.append(prerequisites.get_redis_status())
 

reflex/app_mixins/lifespan.py

@@ -41,13 +41,13 @@ class LifespanMixin(AppMixin):
                         signature = inspect.signature(task)
                         if "app" in signature.parameters:
                             task = functools.partial(task, app=app)
-                        _t = task()
-                        if isinstance(_t, contextlib._AsyncGeneratorContextManager):
-                            await stack.enter_async_context(_t)
+                        t_ = task()
+                        if isinstance(t_, contextlib._AsyncGeneratorContextManager):
+                            await stack.enter_async_context(t_)
                             console.debug(run_msg.format(type="asynccontextmanager"))
-                        elif isinstance(_t, Coroutine):
+                        elif isinstance(t_, Coroutine):
                             task_ = asyncio.create_task(
-                                _t,
+                                t_,
                                 name=f"reflex_lifespan_task|{task_name}|{time.time()}",
                             )
                             task_.add_done_callback(lambda t: t.result())
@@ -71,6 +71,13 @@ class LifespanMixin(AppMixin):
                     await event_namespace._token_manager.disconnect_all()
             except Exception as e:
                 console.error(f"Error during lifespan cleanup: {e}")
+        # Flush any pending writes from the state manager.
+        try:
+            state_manager = self.state_manager  # pyright: ignore[reportAttributeAccessIssue]
+        except AttributeError:
+            pass
+        else:
+            await state_manager.close()
 
     def register_lifespan_task(self, task: Callable | asyncio.Task, **task_kwargs):
         """Register a task to run during the lifespan of the app.

reflex/base.py

@@ -48,6 +48,7 @@ if find_spec("pydantic") and find_spec("pydantic.v1"):
                 self.dict(),
                 default=serialize,
             )
+
 else:
 
     class PydanticNotFoundFallback:

reflex/compiler/compiler.py

@@ -758,12 +758,10 @@ def into_component(component: Component | ComponentCallable) -> Component:
                 raise TypeError(
                     "Cannot pass a Var to a built-in function. Consider using .length() for accessing the length of an iterable Var."
                 ).with_traceback(e.__traceback__) from None
-            if message.endswith(
-                (
-                    "indices must be integers or slices, not NumberCastedVar",
-                    "indices must be integers or slices, not BooleanCastedVar",
-                )
-            ):
+            if message.endswith((
+                "indices must be integers or slices, not NumberCastedVar",
+                "indices must be integers or slices, not BooleanCastedVar",
+            )):
                 raise TypeError(
                     "Cannot index into a primitive sequence with a Var. Consider calling rx.Var.create() on the sequence."
                 ).with_traceback(e.__traceback__) from None

reflex/compiler/templates.py

@@ -83,9 +83,9 @@ class _RenderUtils:
 
     @staticmethod
     def render_iterable_tag(component: Any) -> str:
-        children_rendered = "".join(
-            [_RenderUtils.render(child) for child in component.get("children", [])]
-        )
+        children_rendered = "".join([
+            _RenderUtils.render(child) for child in component.get("children", [])
+        ])
         return f"Array.prototype.map.call({component['iterable_state']} ?? [],(({component['arg_name']},{component['arg_index']})=>({children_rendered})))"
 
     @staticmethod
@@ -189,16 +189,14 @@ def app_root_template(
 
     custom_code_str = "\n".join(custom_codes)
 
-    import_window_libraries = "\n".join(
-        [
-            f'import * as {lib_alias} from "{lib_path}";'
-            for lib_alias, lib_path in window_libraries
-        ]
-    )
+    import_window_libraries = "\n".join([
+        f'import * as {lib_alias} from "{lib_path}";'
+        for lib_alias, lib_path in window_libraries
+    ])
 
-    window_imports_str = "\n".join(
-        [f'    "{lib_path}": {lib_alias},' for lib_alias, lib_path in window_libraries]
-    )
+    window_imports_str = "\n".join([
+        f'    "{lib_path}": {lib_alias},' for lib_alias, lib_path in window_libraries
+    ])
 
     return f"""
 {imports_str}
@@ -277,12 +275,10 @@ def context_template(
         Rendered context file content as string.
     """
     initial_state = initial_state or {}
-    state_contexts_str = "".join(
-        [
-            f"{format_state_name(state_name)}: createContext(null),"
-            for state_name in initial_state
-        ]
-    )
+    state_contexts_str = "".join([
+        f"{format_state_name(state_name)}: createContext(null),"
+        for state_name in initial_state
+    ])
 
     state_str = (
         rf"""
@@ -486,16 +482,14 @@ def package_json_template(
     Returns:
         Rendered package.json content as string.
     """
-    return json.dumps(
-        {
-            "name": "reflex",
-            "type": "module",
-            "scripts": scripts,
-            "dependencies": dependencies,
-            "devDependencies": dev_dependencies,
-            "overrides": overrides,
-        }
-    )
+    return json.dumps({
+        "name": "reflex",
+        "type": "module",
+        "scripts": scripts,
+        "dependencies": dependencies,
+        "devDependencies": dev_dependencies,
+        "overrides": overrides,
+    })
 
 
 def vite_config_template(base: str, hmr: bool, force_full_reload: bool):
@@ -693,9 +687,9 @@ def styles_template(stylesheets: list[str]) -> str:
     Returns:
         Rendered styles.css content as string.
     """
-    return "@layer __reflex_base;\n" + "\n".join(
-        [f"@import url('{sheet_name}');" for sheet_name in stylesheets]
-    )
+    return "@layer __reflex_base;\n" + "\n".join([
+        f"@import url('{sheet_name}');" for sheet_name in stylesheets
+    ])
 
 
 def _render_hooks(hooks: dict[str, VarData | None], memo: list | None = None) -> str:

reflex/compiler/utils.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import concurrent.futures
+import operator
 import traceback
 from collections.abc import Mapping, Sequence
 from datetime import datetime
@@ -161,7 +162,7 @@ def get_import_dict(
     return _ImportDict(
         lib=lib,
         default=default,
-        rest=rest if rest else [],
+        rest=rest or [],
     )
 
 
@@ -190,7 +191,7 @@ def _sorted_keys(d: Mapping[str, Any]) -> dict[str, Any]:
     Returns:
         A new dictionary with sorted keys.
     """
-    return dict(sorted(d.items(), key=lambda kv: kv[0]))
+    return dict(sorted(d.items(), key=operator.itemgetter(0)))
 
 
 def compile_state(state: type[BaseState]) -> dict:
@@ -442,9 +443,9 @@ def create_theme(style: ComponentStyle) -> dict:
 
     root_style = {
         # Root styles.
-        ":root": Style(
-            {f"*{k}": v for k, v in style_rules.items() if k.startswith(":")}
-        ),
+        ":root": Style({
+            f"*{k}": v for k, v in style_rules.items() if k.startswith(":")
+        }),
         # Body styles.
         "body": Style(
             {k: v for k, v in style_rules.items() if not k.startswith(":")},