reflex 0.5.5a2__py3-none-any.whl → 0.5.6__py3-none-any.whl

reflex/state.py

@@ -40,6 +40,7 @@ from redis.exceptions import ResponseError
 
 from reflex import constants
 from reflex.base import Base
+from reflex.config import get_config
 from reflex.event import (
     BACKGROUND_TASK_MARKER,
     Event,
@@ -197,16 +198,6 @@ def _no_chain_background_task(
     raise TypeError(f"{fn} is marked as a background task, but is not async.")
 
 
-RESERVED_BACKEND_VAR_NAMES = {
-    "_backend_vars",
-    "_computed_var_dependencies",
-    "_substate_var_dependencies",
-    "_always_dirty_computed_vars",
-    "_always_dirty_substates",
-    "_was_touched",
-}
-
-
 def _substate_key(
     token: str,
     state_cls_or_name: BaseState | Type[BaseState] | str | list[str],
@@ -313,10 +304,10 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     # Vars inherited by the parent state.
     inherited_vars: ClassVar[Dict[str, Var]] = {}
 
-    # Backend vars that are never sent to the client.
+    # Backend base vars that are never sent to the client.
     backend_vars: ClassVar[Dict[str, Any]] = {}
 
-    # Backend vars inherited
+    # Backend base vars inherited
     inherited_backend_vars: ClassVar[Dict[str, Any]] = {}
 
     # The event handlers.
@@ -352,7 +343,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     # The routing path that triggered the state
     router_data: Dict[str, Any] = {}
 
-    # Per-instance copy of backend variable values
+    # Per-instance copy of backend base variable values
     _backend_vars: Dict[str, Any] = {}
 
     # The router data for the current page
@@ -409,11 +400,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         # Create a fresh copy of the backend variables for this instance
         self._backend_vars = copy.deepcopy(
-            {
-                name: item
-                for name, item in self.backend_vars.items()
-                if name not in self.computed_vars
-            }
+            {name: item for name, item in self.backend_vars.items()}
         )
 
     def __repr__(self) -> str:
@@ -500,25 +487,12 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         new_backend_vars = {
             name: value
             for name, value in cls.__dict__.items()
-            if types.is_backend_variable(name, cls)
-            and name not in RESERVED_BACKEND_VAR_NAMES
-            and name not in cls.inherited_backend_vars
-            and not isinstance(value, FunctionType)
-            and not isinstance(value, ComputedVar)
-        }
-
-        # Get backend computed vars
-        backend_computed_vars = {
-            v._var_name: v._var_set_state(cls)
-            for v in computed_vars
-            if types.is_backend_variable(v._var_name, cls)
-            and v._var_name not in cls.inherited_backend_vars
+            if types.is_backend_base_variable(name, cls)
         }
 
         cls.backend_vars = {
             **cls.inherited_backend_vars,
             **new_backend_vars,
-            **backend_computed_vars,
         }
 
         # Set the base and computed vars.
@@ -560,6 +534,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                     cls.computed_vars[newcv._var_name] = newcv
                     cls.vars[newcv._var_name] = newcv
                     continue
+                if types.is_backend_base_variable(name, mixin):
+                    cls.backend_vars[name] = copy.deepcopy(value)
+                    continue
                 if events.get(name) is not None:
                     continue
                 if not cls._item_is_event_handler(name, value):
@@ -743,7 +720,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 "dirty_substates",
                 "router_data",
             }
-            | RESERVED_BACKEND_VAR_NAMES
+            | types.RESERVED_BACKEND_VAR_NAMES
         )
 
     @classmethod
@@ -1096,10 +1073,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             setattr(self.parent_state, name, value)
             return
 
-        if (
-            types.is_backend_variable(name, self.__class__)
-            and name not in RESERVED_BACKEND_VAR_NAMES
-        ):
+        if name in self.backend_vars:
             self._backend_vars.__setitem__(name, value)
             self.dirty_vars.add(name)
             self._mark_dirty()
@@ -1550,11 +1524,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if self.computed_vars[cvar].needs_update(instance=self)
         )
 
-    def _dirty_computed_vars(self, from_vars: set[str] | None = None) -> set[str]:
+    def _dirty_computed_vars(
+        self, from_vars: set[str] | None = None, include_backend: bool = True
+    ) -> set[str]:
         """Determine ComputedVars that need to be recalculated based on the given vars.
 
         Args:
             from_vars: find ComputedVar that depend on this set of vars. If unspecified, will use the dirty_vars.
+            include_backend: whether to include backend vars in the calculation.
 
         Returns:
             Set of computed vars to include in the delta.
@@ -1563,6 +1540,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             cvar
             for dirty_var in from_vars or self.dirty_vars
             for cvar in self._computed_var_dependencies[dirty_var]
+            if include_backend or not self.computed_vars[cvar]._backend
         )
 
     @classmethod
@@ -1598,19 +1576,23 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         self.dirty_vars.update(self._always_dirty_computed_vars)
         self._mark_dirty()
 
+        frontend_computed_vars: set[str] = {
+            name for name, cv in self.computed_vars.items() if not cv._backend
+        }
+
         # Return the dirty vars for this instance, any cached/dependent computed vars,
         # and always dirty computed vars (cache=False)
         delta_vars = (
             self.dirty_vars.intersection(self.base_vars)
-            .union(self.dirty_vars.intersection(self.computed_vars))
-            .union(self._dirty_computed_vars())
+            .union(self.dirty_vars.intersection(frontend_computed_vars))
+            .union(self._dirty_computed_vars(include_backend=False))
             .union(self._always_dirty_computed_vars)
         )
 
         subdelta = {
             prop: getattr(self, prop)
             for prop in delta_vars
-            if not types.is_backend_variable(prop, self.__class__)
+            if not types.is_backend_base_variable(prop, type(self))
         }
         if len(subdelta) > 0:
             delta[self.get_full_name()] = subdelta
@@ -1739,12 +1721,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                     else self.get_value(getattr(self, prop_name))
                 )
                 for prop_name, cv in self.computed_vars.items()
+                if not cv._backend
             }
         elif include_computed:
             computed_vars = {
                 # Include the computed vars.
                 prop_name: self.get_value(getattr(self, prop_name))
-                for prop_name in self.computed_vars
+                for prop_name, cv in self.computed_vars.items()
+                if not cv._backend
             }
         else:
             computed_vars = {}
@@ -1757,6 +1741,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             for v in self.substates.values()
         ]:
             d.update(substate_d)
+
         return d
 
     async def __aenter__(self) -> BaseState:
@@ -2202,7 +2187,14 @@ class StateManager(Base, ABC):
         """
         redis = prerequisites.get_redis()
         if redis is not None:
-            return StateManagerRedis(state=state, redis=redis)
+            # make sure expiration values are obtained only from the config object on creation
+            config = get_config()
+            return StateManagerRedis(
+                state=state,
+                redis=redis,
+                token_expiration=config.redis_token_expiration,
+                lock_expiration=config.redis_lock_expiration,
+            )
         return StateManagerMemory(state=state)
 
     @abstractmethod
@@ -2326,6 +2318,24 @@ def _dill_reduce_state(pickler, obj):
         dill.Pickler.dispatch[type](pickler, obj)
 
 
+def _default_lock_expiration() -> int:
+    """Get the default lock expiration time.
+
+    Returns:
+        The default lock expiration time.
+    """
+    return get_config().redis_lock_expiration
+
+
+def _default_token_expiration() -> int:
+    """Get the default token expiration time.
+
+    Returns:
+        The default token expiration time.
+    """
+    return get_config().redis_token_expiration
+
+
 class StateManagerRedis(StateManager):
     """A state manager that stores states in redis."""
 
@@ -2333,10 +2343,10 @@ class StateManagerRedis(StateManager):
     redis: Redis
 
     # The token expiration time (s).
-    token_expiration: int = constants.Expiration.TOKEN
+    token_expiration: int = pydantic.Field(default_factory=_default_token_expiration)
 
     # The maximum time to hold a lock (ms).
-    lock_expiration: int = constants.Expiration.LOCK
+    lock_expiration: int = pydantic.Field(default_factory=_default_lock_expiration)
 
     # The keyspace subscription string when redis is waiting for lock to be released
     _redis_notify_keyspace_events: str = (

reflex/style.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Literal, Tuple, Type
 
 from reflex import constants
+from reflex.components.core.breakpoints import Breakpoints, breakpoints_values
 from reflex.event import EventChain
 from reflex.utils import format
 from reflex.utils.imports import ImportVar
@@ -86,8 +87,6 @@ toggle_color_mode = _color_mode_var(
     _var_type=EventChain,
 )
 
-breakpoints = ["0", "30em", "48em", "62em", "80em", "96em"]
-
 STYLE_PROP_SHORTHAND_MAPPING = {
     "paddingX": ("paddingInlineStart", "paddingInlineEnd"),
     "paddingY": ("paddingTop", "paddingBottom"),
@@ -100,16 +99,16 @@ STYLE_PROP_SHORTHAND_MAPPING = {
 }
 
 
-def media_query(breakpoint_index: int):
+def media_query(breakpoint_expr: str):
     """Create a media query selector.
 
     Args:
-        breakpoint_index: The index of the breakpoint to use.
+        breakpoint_expr: The CSS expression representing the breakpoint.
 
     Returns:
         The media query selector used as a key in emotion css dict.
     """
-    return f"@media screen and (min-width: {breakpoints[breakpoint_index]})"
+    return f"@media screen and (min-width: {breakpoint_expr})"
 
 
 def convert_item(style_item: str | Var) -> tuple[str, VarData | None]:
@@ -189,6 +188,10 @@ def convert(style_dict):
             update_out_dict(return_val, keys)
         # Combine all the collected VarData instances.
         var_data = VarData.merge(var_data, new_var_data)
+
+    if isinstance(style_dict, Breakpoints):
+        out = Breakpoints(out).factorize()
+
     return out, var_data
 
 
@@ -295,14 +298,22 @@ def format_as_emotion(style_dict: dict[str, Any]) -> Style | None:
 
     for orig_key, value in style_dict.items():
         key = _format_emotion_style_pseudo_selector(orig_key)
-        if isinstance(value, list):
-            # Apply media queries from responsive value list.
-            mbps = {
-                media_query(bp): (
-                    bp_value if isinstance(bp_value, dict) else {key: bp_value}
-                )
-                for bp, bp_value in enumerate(value)
-            }
+        if isinstance(value, (Breakpoints, list)):
+            if isinstance(value, Breakpoints):
+                mbps = {
+                    media_query(bp): (
+                        bp_value if isinstance(bp_value, dict) else {key: bp_value}
+                    )
+                    for bp, bp_value in value.items()
+                }
+            else:
+                # Apply media queries from responsive value list.
+                mbps = {
+                    media_query([0, *breakpoints_values][bp]): (
+                        bp_value if isinstance(bp_value, dict) else {key: bp_value}
+                    )
+                    for bp, bp_value in enumerate(value)
+                }
             if key.startswith("&:"):
                 emotion_style[key] = mbps
             else:

reflex/utils/codespaces.py

@@ -0,0 +1,94 @@
+"""Utilities for working with Github Codespaces."""
+
+from __future__ import annotations
+
+import os
+
+from fastapi.responses import HTMLResponse
+
+from reflex.components.base.script import Script
+from reflex.components.component import Component
+from reflex.components.core.banner import has_connection_errors
+from reflex.components.core.cond import cond
+from reflex.constants import Endpoint
+
+redirect_script = """
+const thisUrl = new URL(window.location.href);
+const params = new URLSearchParams(thisUrl.search)
+
+function doRedirect(url) {
+    if (!window.sessionStorage.getItem("authenticated_github_codespaces")) {
+        const a = document.createElement("a");
+        if (params.has("redirect_to")) {
+            a.href = params.get("redirect_to")
+        } else if (!window.location.href.startsWith(url)) {
+            a.href = url + `?redirect_to=${window.location.href}`
+        } else {
+            return
+        }
+        a.hidden = true;
+        a.click();
+        a.remove();
+        window.sessionStorage.setItem("authenticated_github_codespaces", "true")
+    }
+}
+doRedirect("%s")
+""" % Endpoint.AUTH_CODESPACE.get_url()
+
+
+def codespaces_port_forwarding_domain() -> str | None:
+    """Get the domain for port forwarding in Github Codespaces.
+
+    Returns:
+        The domain for port forwarding in Github Codespaces, or None if not running in Codespaces.
+    """
+    GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN = os.getenv(
+        "GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN"
+    )
+    return GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN
+
+
+def is_running_in_codespaces() -> bool:
+    """Check if the app is running in Github Codespaces.
+
+    Returns:
+        True if running in Github Codespaces, False otherwise.
+    """
+    return codespaces_port_forwarding_domain() is not None
+
+
+def codespaces_auto_redirect() -> list[Component]:
+    """Get the components for automatically redirecting back to the app after authenticating a codespace port forward.
+
+    Returns:
+        A list containing the conditional redirect component, or empty list.
+    """
+    if is_running_in_codespaces():
+        return [cond(has_connection_errors, Script.create(redirect_script))]
+    return []
+
+
+async def auth_codespace() -> HTMLResponse:
+    """Page automatically redirecting back to the app after authenticating a codespace port forward.
+
+    Returns:
+        An HTML response with an embedded script to redirect back to the app.
+    """
+    return HTMLResponse(
+        """
+    <html>
+        <head>
+            <title>Reflex Github Codespace Forward Successfully Authenticated</title>
+        </head>
+        <body>
+            <center>
+                <h2>Successfully Authenticated</h2>
+            </center>
+            <script language="javascript">
+                %s
+            </script>
+        </body>
+    </html>
+    """
+        % redirect_script
+    )

reflex/utils/compat.py

@@ -4,6 +4,27 @@ import contextlib
 import sys
 
 
+async def windows_hot_reload_lifespan_hack():
+    """[REF-3164] A hack to fix hot reload on Windows.
+
+    Uvicorn has an issue stopping itself on Windows after detecting changes in
+    the filesystem.
+
+    This workaround repeatedly prints and flushes null characters to stderr,
+    which seems to allow the uvicorn server to exit when the CTRL-C signal is
+    sent from the reloader process.
+
+    Don't ask me why this works, I discovered it by accident - masenf.
+    """
+    import asyncio
+    import sys
+
+    while True:
+        sys.stderr.write("\0")
+        sys.stderr.flush()
+        await asyncio.sleep(0.5)
+
+
 @contextlib.contextmanager
 def pydantic_v1_patch():
     """A context manager that patches the Pydantic module to mimic v1 behaviour.

reflex/utils/exceptions.py

@@ -61,6 +61,10 @@ class VarOperationTypeError(ReflexError, TypeError):
     """Custom TypeError for when unsupported operations are performed on vars."""
 
 
+class VarDependencyError(ReflexError, ValueError):
+    """Custom ValueError for when a var depends on a non-existent var."""
+
+
 class InvalidStylePropError(ReflexError, TypeError):
     """Custom Type Error when style props have invalid values."""
 

reflex/utils/format.py

@@ -210,10 +210,31 @@ def _escape_js_string(string: str) -> str:
     Returns:
         The escaped string.
     """
-    # Escape backticks.
-    string = string.replace(r"\`", "`")
-    string = string.replace("`", r"\`")
-    return string
+
+    # TODO: we may need to re-vist this logic after new Var API is implemented.
+    def escape_outside_segments(segment):
+        """Escape backticks in segments outside of `${}`.
+
+        Args:
+            segment: The part of the string to escape.
+
+        Returns:
+            The escaped or unescaped segment.
+        """
+        if segment.startswith("${") and segment.endswith("}"):
+            # Return the `${}` segment unchanged
+            return segment
+        else:
+            # Escape backticks in the segment
+            segment = segment.replace(r"\`", "`")
+            segment = segment.replace("`", r"\`")
+            return segment
+
+    # Split the string into parts, keeping the `${}` segments
+    parts = re.split(r"(\$\{.*?\})", string)
+    escaped_parts = [escape_outside_segments(part) for part in parts]
+    escaped_string = "".join(escaped_parts)
+    return escaped_string
 
 
 def _wrap_js_string(string: str) -> str:

reflex/utils/prerequisites.py

@@ -949,22 +949,9 @@ def needs_reinit(frontend: bool = True) -> bool:
         return True
 
     if constants.IS_WINDOWS:
-        import uvicorn
-
-        uvi_ver = uvicorn.__version__
         console.warn(
             """Windows Subsystem for Linux (WSL) is recommended for improving initial install times."""
         )
-        if sys.version_info >= (3, 12):
-            console.warn(
-                "Python 3.12 on Windows has known issues with hot reload (reflex-dev/reflex#3536). "
-                "Python 3.11 is recommended with this release of Reflex."
-            )
-
-        if sys.version_info < (3, 12) and uvi_ver != "0.20.0":
-            console.warn(
-                f"""On Python < 3.12, `uvicorn==0.20.0` is recommended for improved hot reload times.  Found {uvi_ver} instead."""
-            )
 
         if windows_check_onedrive_in_path():
             console.warn(