reflex 0.5.10a3__py3-none-any.whl → 0.6.0__py3-none-any.whl

reflex/style.py

@@ -6,12 +6,13 @@ 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.event import EventChain, EventHandler
 from reflex.utils import format
+from reflex.utils.exceptions import ReflexError
 from reflex.utils.imports import ImportVar
-from reflex.vars import BaseVar, CallableVar, Var, VarData
-
-VarData.update_forward_refs()  # Ensure all type definitions are resolved
+from reflex.vars import VarData
+from reflex.vars.base import CallableVar, LiteralVar, Var
+from reflex.vars.function import FunctionVar
 
 SYSTEM_COLOR_MODE: str = "system"
 LIGHT_COLOR_MODE: str = "light"
@@ -25,32 +26,30 @@ color_mode_imports = {
 }
 
 
-def _color_mode_var(_var_name: str, _var_type: Type = str) -> BaseVar:
-    """Create a Var that destructs the _var_name from ColorModeContext.
+def _color_mode_var(_js_expr: str, _var_type: Type = str) -> Var:
+    """Create a Var that destructs the _js_expr from ColorModeContext.
 
     Args:
-        _var_name: The name of the variable to get from ColorModeContext.
+        _js_expr: The name of the variable to get from ColorModeContext.
         _var_type: The type of the Var.
 
     Returns:
-        The BaseVar for accessing _var_name from ColorModeContext.
+        The Var that resolves to the color mode.
     """
-    return BaseVar(
-        _var_name=_var_name,
+    return Var(
+        _js_expr=_js_expr,
         _var_type=_var_type,
-        _var_is_local=False,
-        _var_is_string=False,
         _var_data=VarData(
             imports=color_mode_imports,
-            hooks={f"const {{ {_var_name} }} = useContext(ColorModeContext)": None},
+            hooks={f"const {{ {_js_expr} }} = useContext(ColorModeContext)": None},
         ),
-    )
+    ).guess_type()
 
 
 @CallableVar
 def set_color_mode(
     new_color_mode: LiteralColorMode | Var[LiteralColorMode] | None = None,
-) -> BaseVar[EventChain]:
+) -> Var[EventChain]:
     """Create an EventChain Var that sets the color mode to a specific value.
 
     Note: `set_color_mode` is not a real event and cannot be triggered from a
@@ -63,27 +62,30 @@ def set_color_mode(
         The EventChain Var that can be passed to an event trigger.
     """
     base_setter = _color_mode_var(
-        _var_name=constants.ColorMode.SET,
+        _js_expr=constants.ColorMode.SET,
         _var_type=EventChain,
     )
     if new_color_mode is None:
         return base_setter
 
     if not isinstance(new_color_mode, Var):
-        new_color_mode = Var.create_safe(new_color_mode, _var_is_string=True)
-    return base_setter._replace(
-        _var_name=f"() => {base_setter._var_name}({new_color_mode._var_name_unwrapped})",
-        merge_var_data=new_color_mode._var_data,
-    )
+        new_color_mode = LiteralVar.create(new_color_mode)
+
+    return Var(
+        f"() => {str(base_setter)}({str(new_color_mode)})",
+        _var_data=VarData.merge(
+            base_setter._get_all_var_data(), new_color_mode._get_all_var_data()
+        ),
+    ).to(FunctionVar, EventChain)  # type: ignore
 
 
 # Var resolves to the current color mode for the app ("light", "dark" or "system")
-color_mode = _color_mode_var(_var_name=constants.ColorMode.NAME)
+color_mode = _color_mode_var(_js_expr=constants.ColorMode.NAME)
 # Var resolves to the resolved color mode for the app ("light" or "dark")
-resolved_color_mode = _color_mode_var(_var_name=constants.ColorMode.RESOLVED_NAME)
+resolved_color_mode = _color_mode_var(_js_expr=constants.ColorMode.RESOLVED_NAME)
 # Var resolves to a function invocation that toggles the color mode
 toggle_color_mode = _color_mode_var(
-    _var_name=constants.ColorMode.TOGGLE,
+    _js_expr=constants.ColorMode.TOGGLE,
     _var_type=EventChain,
 )
 
@@ -111,7 +113,9 @@ def media_query(breakpoint_expr: str):
     return f"@media screen and (min-width: {breakpoint_expr})"
 
 
-def convert_item(style_item: str | Var) -> tuple[str, VarData | None]:
+def convert_item(
+    style_item: int | str | Var,
+) -> tuple[str | Var, VarData | None]:
     """Format a single value in a style dictionary.
 
     Args:
@@ -119,23 +123,31 @@ def convert_item(style_item: str | Var) -> tuple[str, VarData | None]:
 
     Returns:
         The formatted style item and any associated VarData.
+
+    Raises:
+        ReflexError: If an EventHandler is used as a style value
     """
+    if isinstance(style_item, EventHandler):
+        raise ReflexError(
+            "EventHandlers cannot be used as style values. "
+            "Please use a Var or a literal value."
+        )
+
     if isinstance(style_item, Var):
-        # If the value is a Var, extract the var_data and cast as str.
-        return str(style_item), style_item._var_data
+        return style_item, style_item._get_all_var_data()
 
-    # Otherwise, convert to Var to collapse VarData encoded in f-string.
-    new_var = Var.create(style_item, _var_is_string=False)
-    if new_var is not None and new_var._var_data:
-        # The wrapped backtick is used to identify the Var for interpolation.
-        return f"`{str(new_var)}`", new_var._var_data
+    # if isinstance(style_item, str) and REFLEX_VAR_OPENING_TAG not in style_item:
+    #     return style_item, None
 
-    return style_item, None
+    # Otherwise, convert to Var to collapse VarData encoded in f-string.
+    new_var = LiteralVar.create(style_item)
+    var_data = new_var._get_all_var_data() if new_var is not None else None
+    return new_var, var_data
 
 
 def convert_list(
     responsive_list: list[str | dict | Var],
-) -> tuple[list[str | dict], VarData | None]:
+) -> tuple[list[str | dict[str, Var | list | dict]], VarData | None]:
     """Format a responsive value list.
 
     Args:
@@ -157,7 +169,9 @@ def convert_list(
     return converted_value, VarData.merge(*item_var_datas)
 
 
-def convert(style_dict):
+def convert(
+    style_dict: dict[str, Var | dict | list | str],
+) -> tuple[dict[str, str | list | dict], VarData | None]:
     """Format a style dictionary.
 
     Args:
@@ -175,7 +189,11 @@ def convert(style_dict):
 
     for key, value in style_dict.items():
         keys = format_style_key(key)
-        if isinstance(value, dict):
+        if isinstance(value, Var):
+            return_val = value
+            new_var_data = value._get_all_var_data()
+            update_out_dict(return_val, keys)
+        elif isinstance(value, dict):
             # Recursively format nested style dictionaries.
             return_val, new_var_data = convert(value)
             update_out_dict(return_val, keys)
@@ -254,10 +272,10 @@ class Style(dict):
             value: The value to set.
         """
         # Create a Var to collapse VarData encoded in f-string.
-        _var = Var.create(value, _var_is_string=False)
+        _var = LiteralVar.create(value)
         if _var is not None:
             # Carry the imports/hooks when setting a Var as a value.
-            self._var_data = VarData.merge(self._var_data, _var._var_data)
+            self._var_data = VarData.merge(self._var_data, _var._get_all_var_data())
         super().__setitem__(key, value)
 
 
@@ -272,7 +290,6 @@ def _format_emotion_style_pseudo_selector(key: str) -> str:
     """
     prefix = None
     if key.startswith("_"):
-        # Handle pseudo selectors in chakra style format.
         prefix = "&:"
         key = key[1:]
     if key.startswith(":"):

reflex/testing.py

@@ -45,6 +45,8 @@ import reflex.utils.prerequisites
 import reflex.utils.processes
 from reflex.state import (
     BaseState,
+    StateManager,
+    StateManagerDisk,
     StateManagerMemory,
     StateManagerRedis,
     reload_state_module,
@@ -126,7 +128,7 @@ class AppHarness:
     frontend_output_thread: Optional[threading.Thread] = None
     backend_thread: Optional[threading.Thread] = None
     backend: Optional[uvicorn.Server] = None
-    state_manager: Optional[StateManagerMemory | StateManagerRedis] = None
+    state_manager: Optional[StateManager] = None
     _frontends: list["WebDriver"] = dataclasses.field(default_factory=list)
     _decorated_pages: list = dataclasses.field(default_factory=list)
 
@@ -290,6 +292,8 @@ class AppHarness:
         if isinstance(self.app_instance._state_manager, StateManagerRedis):
             # Create our own redis connection for testing.
             self.state_manager = StateManagerRedis.create(self.app_instance.state)
+        elif isinstance(self.app_instance._state_manager, StateManagerDisk):
+            self.state_manager = StateManagerDisk.create(self.app_instance.state)
         else:
             self.state_manager = self.app_instance._state_manager
 
@@ -327,7 +331,8 @@ class AppHarness:
             )
         )
         self.backend.shutdown = self._get_backend_shutdown_handler()
-        self.backend_thread = threading.Thread(target=self.backend.run)
+        with chdir(self.app_path):
+            self.backend_thread = threading.Thread(target=self.backend.run)
         self.backend_thread.start()
 
     async def _reset_backend_state_manager(self):
@@ -787,7 +792,7 @@ class AppHarness:
             raise RuntimeError("App is not running.")
         state_manager = self.app_instance.state_manager
         assert isinstance(
-            state_manager, StateManagerMemory
+            state_manager, (StateManagerMemory, StateManagerDisk)
         ), "Only works with memory state manager"
         if not self._poll_for(
             target=lambda: state_manager.states,

reflex/utils/exceptions.py

@@ -79,3 +79,35 @@ class LockExpiredError(ReflexError):
 
 class MatchTypeError(ReflexError, TypeError):
     """Raised when the return types of match cases are different."""
+
+
+class EventHandlerArgMismatch(ReflexError, TypeError):
+    """Raised when the number of args accepted by an EventHandler is differs from that provided by the event trigger."""
+
+
+class EventFnArgMismatch(ReflexError, TypeError):
+    """Raised when the number of args accepted by a lambda differs from that provided by the event trigger."""
+
+
+class DynamicRouteArgShadowsStateVar(ReflexError, NameError):
+    """Raised when a dynamic route arg shadows a state var."""
+
+
+class ComputedVarShadowsStateVar(ReflexError, NameError):
+    """Raised when a computed var shadows a state var."""
+
+
+class ComputedVarShadowsBaseVars(ReflexError, NameError):
+    """Raised when a computed var shadows a base var."""
+
+
+class EventHandlerShadowsBuiltInStateMethod(ReflexError, NameError):
+    """Raised when an event handler shadows a built-in state method."""
+
+
+class GeneratedCodeHasNoFunctionDefs(ReflexError):
+    """Raised when refactored code generated with flexgen has no functions defined."""
+
+
+class PrimitiveUnserializableToJSON(ReflexError, ValueError):
+    """Raised when a primitive type is unserializable to JSON. Usually with NaN and Infinity."""

reflex/utils/exec.py

@@ -18,22 +18,11 @@ from reflex import constants
 from reflex.config import get_config
 from reflex.utils import console, path_ops
 from reflex.utils.prerequisites import get_web_dir
-from reflex.utils.watch import AssetFolderWatch
 
 # For uvicorn windows bug fix (#2335)
 frontend_process = None
 
 
-def start_watching_assets_folder(root):
-    """Start watching assets folder.
-
-    Args:
-        root: root path of the project.
-    """
-    asset_watch = AssetFolderWatch(root)
-    asset_watch.start()
-
-
 def detect_package_change(json_file_path: str) -> str:
     """Calculates the SHA-256 hash of a JSON file and returns it as a hexadecimal string.
 
@@ -149,8 +138,6 @@ def run_frontend(root: Path, port: str, backend_present=True):
     """
     from reflex.utils import prerequisites
 
-    # Start watching asset folder.
-    start_watching_assets_folder(root)
     # validate dependencies before run
     prerequisites.validate_frontend_dependencies(init=False)
 
@@ -215,7 +202,6 @@ def run_backend(
         log_level=loglevel.value,
         reload=True,
         reload_dirs=[config.app_name],
-        reload_excludes=[str(web_dir)],
     )