reflex 0.8.15a0__py3-none-any.whl → 0.8.15a2__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/__init__.py

@@ -84,13 +84,18 @@ In the example above, you will be able to do `rx.list`
 
 from __future__ import annotations
 
-from reflex.utils import (
-    compat,  # for side-effects
-    lazy_loader,
-)
+import sys
+
+from reflex.utils import lazy_loader
+
+if sys.version_info < (3, 11):
+    from reflex.utils import console
 
-# Remove the `compat` name from the namespace, it was imported for side-effects only.
-del compat
+    console.warn(
+        "Reflex support for Python 3.10 is deprecated and will be removed in a future release. Please upgrade to Python 3.11 or higher for continued support."
+    )
+    del console
+del sys
 
 RADIX_THEMES_MAPPING: dict = {
     "components.radix.themes.base": ["color_mode", "theme", "theme_panel"],

reflex/__init__.pyi

@@ -3,7 +3,7 @@
 # This file was generated by `reflex/utils/pyi_generator.py`!
 # ------------------------------------------------------
 
-from reflex.utils import compat
+import sys
 
 from . import (
     admin,
@@ -160,7 +160,14 @@ from .utils.misc import run_in_thread
 from .utils.serializers import serializer
 from .vars import Field, Var, field
 
-del compat
+if sys.version_info < (3, 11):
+    from reflex.utils import console
+
+    console.warn(
+        "Reflex support for Python 3.10 is deprecated and will be removed in a future release. Please upgrade to Python 3.11 or higher for continued support."
+    )
+    del console
+del sys
 RADIX_THEMES_MAPPING: dict
 RADIX_THEMES_COMPONENTS_MAPPING: dict
 RADIX_THEMES_LAYOUT_MAPPING: dict

reflex/app.py

@@ -1781,16 +1781,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.

reflex/base.py

@@ -5,7 +5,9 @@ from importlib.util import find_spec
 if find_spec("pydantic") and find_spec("pydantic.v1"):
     from pydantic.v1 import BaseModel
 
-    class Base(BaseModel):
+    from reflex.utils.compat import ModelMetaclassLazyAnnotations
+
+    class Base(BaseModel, metaclass=ModelMetaclassLazyAnnotations):
         """The base class subclassed by all Reflex classes.
 
         This class wraps Pydantic and provides common methods such as
@@ -22,22 +24,17 @@ if find_spec("pydantic") and find_spec("pydantic.v1"):
             use_enum_values = True
             extra = "allow"
 
-        def __init__(self, *args, **kwargs):
-            """Initialize the base class.
-
-            Args:
-                *args: Positional arguments.
-                **kwargs: Keyword arguments.
-            """
+        def __init_subclass__(cls):
+            """Warn that rx.Base is deprecated."""
             from reflex.utils import console
 
             console.deprecate(
                 feature_name="rx.Base",
-                reason="You can subclass from `pydantic.BaseModel` directly instead or use dataclasses if possible.",
-                deprecation_version="0.8.2",
+                reason=f"{cls!r} is subclassing rx.Base. You can subclass from `pydantic.BaseModel` directly instead or use dataclasses if possible.",
+                deprecation_version="0.8.15",
                 removal_version="0.9.0",
             )
-            super().__init__(*args, **kwargs)
+            super().__init_subclass__()
 
         def json(self) -> str:
             """Convert the object to a json string.

reflex/components/field.py

@@ -7,6 +7,7 @@ from dataclasses import _MISSING_TYPE, MISSING
 from typing import Annotated, Any, Generic, TypeVar, get_origin
 
 from reflex.utils import types
+from reflex.utils.compat import annotations_from_namespace
 
 FIELD_TYPE = TypeVar("FIELD_TYPE")
 
@@ -117,7 +118,8 @@ class FieldBasedMeta(type):
         cls, namespace: dict[str, Any], name: str
     ) -> dict[str, Any]:
         return types.resolve_annotations(
-            namespace.get("__annotations__", {}), namespace["__module__"]
+            annotations_from_namespace(namespace),
+            namespace["__module__"],
         )
 
     @classmethod

reflex/components/markdown/markdown.py

@@ -38,6 +38,84 @@ _REHYPE_PLUGINS = LiteralVar.create([_REHYPE_KATEX, _REHYPE_RAW])
 NO_PROPS_TAGS = ("ul", "ol", "li")
 
 
+def _h1(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h1", size="6", margin_y="0.5em")
+
+
+def _h2(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h2", size="5", margin_y="0.5em")
+
+
+def _h3(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h3", size="4", margin_y="0.5em")
+
+
+def _h4(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h4", size="3", margin_y="0.5em")
+
+
+def _h5(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h5", size="2", margin_y="0.5em")
+
+
+def _h6(value: object):
+    from reflex.components.radix.themes.typography.heading import Heading
+
+    return Heading.create(value, as_="h6", size="1", margin_y="0.5em")
+
+
+def _p(value: object):
+    from reflex.components.radix.themes.typography.text import Text
+
+    return Text.create(value, margin_y="1em")
+
+
+def _ul(value: object):
+    from reflex.components.radix.themes.layout.list import UnorderedList
+
+    return UnorderedList.create(value, margin_y="1em")
+
+
+def _ol(value: object):
+    from reflex.components.radix.themes.layout.list import OrderedList
+
+    return OrderedList.create(value, margin_y="1em")
+
+
+def _li(value: object):
+    from reflex.components.radix.themes.layout.list import ListItem
+
+    return ListItem.create(value, margin_y="0.5em")
+
+
+def _a(value: object):
+    from reflex.components.radix.themes.typography.link import Link
+
+    return Link.create(value)
+
+
+def _code(value: object):
+    from reflex.components.radix.themes.typography.code import Code
+
+    return Code.create(value)
+
+
+def _codeblock(value: object, **props):
+    from reflex.components.datadisplay.code import CodeBlock
+
+    return CodeBlock.create(value, margin_y="1em", wrap_long_lines=True, **props)
+
+
 # Component Mapping
 @lru_cache
 def get_base_component_map() -> dict[str, Callable]:
@@ -46,33 +124,20 @@ def get_base_component_map() -> dict[str, Callable]:
     Returns:
         The base component map.
     """
-    from reflex.components.datadisplay.code import CodeBlock
-    from reflex.components.radix.themes.layout.list import (
-        ListItem,
-        OrderedList,
-        UnorderedList,
-    )
-    from reflex.components.radix.themes.typography.code import Code
-    from reflex.components.radix.themes.typography.heading import Heading
-    from reflex.components.radix.themes.typography.link import Link
-    from reflex.components.radix.themes.typography.text import Text
-
     return {
-        "h1": lambda value: Heading.create(value, as_="h1", size="6", margin_y="0.5em"),
-        "h2": lambda value: Heading.create(value, as_="h2", size="5", margin_y="0.5em"),
-        "h3": lambda value: Heading.create(value, as_="h3", size="4", margin_y="0.5em"),
-        "h4": lambda value: Heading.create(value, as_="h4", size="3", margin_y="0.5em"),
-        "h5": lambda value: Heading.create(value, as_="h5", size="2", margin_y="0.5em"),
-        "h6": lambda value: Heading.create(value, as_="h6", size="1", margin_y="0.5em"),
-        "p": lambda value: Text.create(value, margin_y="1em"),
-        "ul": lambda value: UnorderedList.create(value, margin_y="1em"),
-        "ol": lambda value: OrderedList.create(value, margin_y="1em"),
-        "li": lambda value: ListItem.create(value, margin_y="0.5em"),
-        "a": lambda value: Link.create(value),
-        "code": lambda value: Code.create(value),
-        "codeblock": lambda value, **props: CodeBlock.create(
-            value, margin_y="1em", wrap_long_lines=True, **props
-        ),
+        "h1": _h1,
+        "h2": _h2,
+        "h3": _h3,
+        "h4": _h4,
+        "h5": _h5,
+        "h6": _h6,
+        "p": _p,
+        "ul": _ul,
+        "ol": _ol,
+        "li": _li,
+        "a": _a,
+        "code": _code,
+        "codeblock": _codeblock,
     }
 
 
@@ -413,7 +478,16 @@ let {_LANGUAGE!s} = match ? match[1] : '';
     @staticmethod
     def _component_map_hash(component_map: dict) -> str:
         inp = str(
-            {tag: component(_MOCK_ARG) for tag, component in component_map.items()}
+            {
+                tag: (
+                    f"{component.__module__}.{component.__qualname__}"
+                    if (
+                        "<" not in component.__name__
+                    )  # simple way to check against lambdas
+                    else component(_MOCK_ARG)
+                )
+                for tag, component in component_map.items()
+            }
         ).encode()
         return md5(inp).hexdigest()
 

reflex/constants/base.py

@@ -134,6 +134,11 @@ class Templates(SimpleNamespace):
     # The reflex.build frontend host
     REFLEX_BUILD_FRONTEND = "https://build.reflex.dev"
 
+    # The reflex.build frontend with referrer
+    REFLEX_BUILD_FRONTEND_WITH_REFERRER = (
+        f"{REFLEX_BUILD_FRONTEND}/?utm_source=reflex_cli"
+    )
+
     class Dirs(SimpleNamespace):
         """Folders used by the template system of Reflex."""
 

reflex/constants/installer.py

@@ -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.14",
+        "vite": "npm:rolldown-vite@7.1.16",
     }
     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.14",
+        "vite": "npm:rolldown-vite@7.1.16",
     }

reflex/event.py

@@ -1866,6 +1866,9 @@ def fix_events(
     # Fix the events created by the handler.
     out = []
     for e in events:
+        if callable(e) and getattr(e, "__name__", "") == "<lambda>":
+            # A lambda was returned, assume the user wants to call it with no args.
+            e = e()
         if isinstance(e, Event):
             # If the event is already an event, append it to the list.
             out.append(e)

reflex/istate/manager/__init__.py

@@ -0,0 +1,120 @@
+"""State manager for managing client states."""
+
+import contextlib
+import dataclasses
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+
+from reflex import constants
+from reflex.config import get_config
+from reflex.state import BaseState
+from reflex.utils import console, prerequisites
+from reflex.utils.exceptions import InvalidStateManagerModeError
+
+
+@dataclasses.dataclass
+class StateManager(ABC):
+    """A class to manage many client states."""
+
+    # The state class to use.
+    state: type[BaseState]
+
+    @classmethod
+    def create(cls, state: type[BaseState]):
+        """Create a new state manager.
+
+        Args:
+            state: The state class to use.
+
+        Raises:
+            InvalidStateManagerModeError: If the state manager mode is invalid.
+
+        Returns:
+            The state manager (either disk, memory or redis).
+        """
+        config = get_config()
+        if prerequisites.parse_redis_url() is not None:
+            config.state_manager_mode = constants.StateManagerMode.REDIS
+        if config.state_manager_mode == constants.StateManagerMode.MEMORY:
+            from reflex.istate.manager.memory import StateManagerMemory
+
+            return StateManagerMemory(state=state)
+        if config.state_manager_mode == constants.StateManagerMode.DISK:
+            from reflex.istate.manager.disk import StateManagerDisk
+
+            return StateManagerDisk(state=state)
+        if config.state_manager_mode == constants.StateManagerMode.REDIS:
+            redis = prerequisites.get_redis()
+            if redis is not None:
+                from reflex.istate.manager.redis import StateManagerRedis
+
+                # make sure expiration values are obtained only from the config object on creation
+                return StateManagerRedis(
+                    state=state,
+                    redis=redis,
+                    token_expiration=config.redis_token_expiration,
+                    lock_expiration=config.redis_lock_expiration,
+                    lock_warning_threshold=config.redis_lock_warning_threshold,
+                )
+        msg = f"Expected one of: DISK, MEMORY, REDIS, got {config.state_manager_mode}"
+        raise InvalidStateManagerModeError(msg)
+
+    @abstractmethod
+    async def get_state(self, token: str) -> BaseState:
+        """Get the state for a token.
+
+        Args:
+            token: The token to get the state for.
+
+        Returns:
+            The state for the token.
+        """
+
+    @abstractmethod
+    async def set_state(self, token: str, state: BaseState):
+        """Set the state for a token.
+
+        Args:
+            token: The token to set the state for.
+            state: The state to set.
+        """
+
+    @abstractmethod
+    @contextlib.asynccontextmanager
+    async def modify_state(self, token: str) -> AsyncIterator[BaseState]:
+        """Modify the state for a token while holding exclusive lock.
+
+        Args:
+            token: The token to modify the state for.
+
+        Yields:
+            The state for the token.
+        """
+        yield self.state()
+
+
+def _default_token_expiration() -> int:
+    """Get the default token expiration time.
+
+    Returns:
+        The default token expiration time.
+    """
+    return get_config().redis_token_expiration
+
+
+def reset_disk_state_manager():
+    """Reset the disk state manager."""
+    console.debug("Resetting disk state manager.")
+    states_directory = prerequisites.get_states_dir()
+    if states_directory.exists():
+        for path in states_directory.iterdir():
+            path.unlink()
+
+
+def get_state_manager() -> StateManager:
+    """Get the state manager for the app that is currently running.
+
+    Returns:
+        The state manager.
+    """
+    return prerequisites.get_and_validate_app().app.state_manager