reflex 0.4.9a1__py3-none-any.whl → 0.5.0__py3-none-any.whl

reflex/state.py

@@ -7,9 +7,7 @@ import contextlib
 import copy
 import functools
 import inspect
-import json
 import traceback
-import urllib.parse
 import uuid
 from abc import ABC, abstractmethod
 from collections import defaultdict
@@ -31,13 +29,7 @@ from typing import (
 import dill
 
 try:
-    # TODO The type checking guard can be removed once
-    # reflex-hosting-cli tools are compatible with pydantic v2
-
-    if not TYPE_CHECKING:
-        import pydantic.v1 as pydantic
-    else:
-        raise ModuleNotFoundError
+    import pydantic.v1 as pydantic
 except ModuleNotFoundError:
     import pydantic
 
@@ -47,6 +39,7 @@ from redis.asyncio import Redis
 from reflex import constants
 from reflex.base import Base
 from reflex.event import (
+    BACKGROUND_TASK_MARKER,
     Event,
     EventHandler,
     EventSpec,
@@ -247,6 +240,60 @@ def _split_substate_key(substate_key: str) -> tuple[str, str]:
     return token, state_name
 
 
+class EventHandlerSetVar(EventHandler):
+    """A special event handler to wrap setvar functionality."""
+
+    state_cls: Type[BaseState]
+
+    def __init__(self, state_cls: Type[BaseState]):
+        """Initialize the EventHandlerSetVar.
+
+        Args:
+            state_cls: The state class that vars will be set on.
+        """
+        super().__init__(
+            fn=type(self).setvar,
+            state_full_name=state_cls.get_full_name(),
+            state_cls=state_cls,  # type: ignore
+        )
+
+    def setvar(self, var_name: str, value: Any):
+        """Set the state variable to the value of the event.
+
+        Note: `self` here will be an instance of the state, not EventHandlerSetVar.
+
+        Args:
+            var_name: The name of the variable to set.
+            value: The value to set the variable to.
+        """
+        getattr(self, constants.SETTER_PREFIX + var_name)(value)
+
+    def __call__(self, *args: Any) -> EventSpec:
+        """Performs pre-checks and munging on the provided args that will become an EventSpec.
+
+        Args:
+            *args: The event args.
+
+        Returns:
+            The (partial) EventSpec that will be used to create the event to setvar.
+
+        Raises:
+            AttributeError: If the given Var name does not exist on the state.
+            ValueError: If the given Var name is not a str
+        """
+        if args:
+            if not isinstance(args[0], str):
+                raise ValueError(
+                    f"Var name must be passed as a string, got {args[0]!r}"
+                )
+            # Check that the requested Var setter exists on the State at compile time.
+            if getattr(self.state_cls, constants.SETTER_PREFIX + args[0], None) is None:
+                raise AttributeError(
+                    f"Variable `{args[0]}` cannot be set on `{self.state_cls.get_full_name()}`"
+                )
+        return super().__call__(*args)
+
+
 class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     """The state of the app."""
 
@@ -310,6 +357,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     # Whether the state has ever been touched since instantiation.
     _was_touched: bool = False
 
+    # A special event handler for setting base vars.
+    setvar: ClassVar[EventHandler]
+
     def __init__(
         self,
         *args,
@@ -393,6 +443,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         super().__init_subclass__(**kwargs)
         # Event handlers should not shadow builtin state methods.
         cls._check_overridden_methods()
+        # Computed vars should not shadow builtin state props.
+        cls._check_overriden_basevars()
 
         # Reset subclass tracking for this class.
         cls.class_subclasses = set()
@@ -500,6 +552,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 value.__qualname__ = f"{cls.__name__}.{name}"
                 events[name] = value
 
+        # Create the setvar event handler for this state
+        cls._create_setvar()
+
         for name, fn in events.items():
             handler = cls._create_event_handler(fn)
             cls.event_handlers[name] = handler
@@ -525,6 +580,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             closure=fn.__closure__,
         )
         newfn.__annotations__ = fn.__annotations__
+        if mark := getattr(fn, BACKGROUND_TASK_MARKER, None):
+            setattr(newfn, BACKGROUND_TASK_MARKER, mark)
         return newfn
 
     @staticmethod
@@ -636,6 +693,19 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 f"The event handler name `{method_name}` shadows a builtin State method; use a different name instead"
             )
 
+    @classmethod
+    def _check_overriden_basevars(cls):
+        """Check for shadow base vars and raise error if any.
+
+        Raises:
+            NameError: When a computed var shadows a base var.
+        """
+        for computed_var_ in cls._get_computed_vars():
+            if computed_var_._var_name in cls.__annotations__:
+                raise NameError(
+                    f"The computed var name `{computed_var_._var_name}` shadows a base var in {cls.__module__}.{cls.__name__}; use a different name instead"
+                )
+
     @classmethod
     def get_skip_vars(cls) -> set[str]:
         """Get the vars to skip when serializing.
@@ -806,7 +876,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         cls.vars.update({name: var})
 
         # let substates know about the new variable
-        for substate_class in cls.__subclasses__():
+        for substate_class in cls.class_subclasses:
             substate_class.vars.setdefault(name, var)
 
         # Reinitialize dependency tracking dicts.
@@ -833,6 +903,11 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         """
         return EventHandler(fn=fn, state_full_name=cls.get_full_name())
 
+    @classmethod
+    def _create_setvar(cls):
+        """Create the setvar method for the state."""
+        cls.setvar = cls.event_handlers["setvar"] = EventHandlerSetVar(state_cls=cls)
+
     @classmethod
     def _create_setter(cls, prop: BaseVar):
         """Create a setter for the var.
@@ -881,124 +956,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if not func[0].startswith("__")
         }
 
-    def get_token(self) -> str:
-        """Return the token of the client associated with this state.
-
-        Returns:
-            The token of the client.
-        """
-        console.deprecate(
-            feature_name="get_token",
-            reason="replaced by `State.router.session.client_token`",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        return self.router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
-
-    def get_sid(self) -> str:
-        """Return the session ID of the client associated with this state.
-
-        Returns:
-            The session ID of the client.
-        """
-        console.deprecate(
-            feature_name="get_sid",
-            reason="replaced by `State.router.session.session_id`",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        return self.router_data.get(constants.RouteVar.SESSION_ID, "")
-
-    def get_headers(self) -> Dict:
-        """Return the headers of the client associated with this state.
-
-        Returns:
-            The headers of the client.
-        """
-        console.deprecate(
-            feature_name="get_headers",
-            reason="replaced by `State.router.headers`",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        return self.router_data.get(constants.RouteVar.HEADERS, {})
-
-    def get_client_ip(self) -> str:
-        """Return the IP of the client associated with this state.
-
-        Returns:
-            The IP of the client.
-        """
-        console.deprecate(
-            feature_name="get_client_ip",
-            reason="replaced by `State.router.session.client_ip`",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        return self.router_data.get(constants.RouteVar.CLIENT_IP, "")
-
-    def get_current_page(self, origin=False) -> str:
-        """Obtain the path of current page from the router data.
-
-        Args:
-            origin: whether to return the base route as shown in browser
-
-        Returns:
-            The current page.
-        """
-        console.deprecate(
-            feature_name="get_current_page",
-            reason="replaced by State.router.page / self.router.page",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-
-        return self.router.page.raw_path if origin else self.router.page.path
-
-    def get_query_params(self) -> dict[str, str]:
-        """Obtain the query parameters for the queried page.
-
-        The query object contains both the URI parameters and the GET parameters.
-
-        Returns:
-            The dict of query parameters.
-        """
-        console.deprecate(
-            feature_name="get_query_params",
-            reason="replaced by `State.router.page.params`",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        return self.router_data.get(constants.RouteVar.QUERY, {})
-
-    def get_cookies(self) -> dict[str, str]:
-        """Obtain the cookies of the client stored in the browser.
-
-        Returns:
-                The dict of cookies.
-        """
-        console.deprecate(
-            feature_name=f"rx.get_cookies",
-            reason="and has been replaced by rx.Cookie, which can be used as a state var",
-            deprecation_version="0.3.0",
-            removal_version="0.5.0",
-        )
-        cookie_dict = {}
-        cookies = self.get_headers().get(constants.RouteVar.COOKIE, "").split(";")
-
-        cookie_pairs = [cookie.split("=") for cookie in cookies if cookie]
-
-        for pair in cookie_pairs:
-            key, value = pair[0].strip(), urllib.parse.unquote(pair[1].strip())
-            try:
-                # cast non-string values to the actual types.
-                value = json.loads(value)
-            except json.JSONDecodeError:
-                pass
-            finally:
-                cookie_dict[key] = value
-        return cookie_dict
-
     @classmethod
     def setup_dynamic_args(cls, args: dict[str, str]):
         """Set up args for easy access in renderer.
@@ -1800,6 +1757,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return state
 
 
+EventHandlerSetVar.update_forward_refs()
+
+
 class State(BaseState):
     """The app Base State."""
 
@@ -1841,7 +1801,7 @@ class OnLoadInternalState(State):
         Returns:
             The list of events to queue for on load handling.
         """
-        # Do not app.compile_()!  It should be already compiled by now.
+        # Do not app._compile()!  It should be already compiled by now.
         app = getattr(prerequisites.get_app(), constants.CompileVars.APP)
         load_events = app.get_load_events(self.router.page.path)
         if not load_events:
@@ -1859,8 +1819,45 @@ class OnLoadInternalState(State):
 
 
 class ComponentState(Base):
-    """The base class for a State that is copied for each Component associated with it."""
+    """Base class to allow for the creation of a state instance per component.
+
+    This allows for the bundling of UI and state logic into a single class,
+    where each instance has a separate instance of the state.
+
+    Subclass this class and define vars and event handlers in the traditional way.
+    Then define a `get_component` method that returns the UI for the component instance.
+
+    See the full [docs](https://reflex.dev/docs/substates/component-state/) for more.
+
+    Basic example:
+    ```python
+    # Subclass ComponentState and define vars and event handlers.
+    class Counter(rx.ComponentState):
+        # Define vars that change.
+        count: int = 0
+
+        # Define event handlers.
+        def increment(self):
+            self.count += 1
+
+        def decrement(self):
+            self.count -= 1
+
+        @classmethod
+        def get_component(cls, **props):
+            # Access the state vars and event handlers using `cls`.
+            return rx.hstack(
+                rx.button("Decrement", on_click=cls.decrement),
+                rx.text(cls.count),
+                rx.button("Increment", on_click=cls.increment),
+                **props,
+            )
+
+    counter = Counter.create()
+    ```
+    """
 
+    # The number of components created from this class.
     _per_component_state_instance_count: ClassVar[int] = 0
 
     @classmethod
@@ -2651,7 +2648,7 @@ class StateManagerRedis(StateManager):
 
         Note: Connections will be automatically reopened when needed.
         """
-        await self.redis.close(close_connection_pool=True)
+        await self.redis.aclose(close_connection_pool=True)
 
 
 def get_state_manager() -> StateManager:

reflex/style.py

@@ -159,12 +159,17 @@ def format_style_key(key: str) -> Tuple[str, ...]:
 class Style(dict):
     """A style dictionary."""
 
-    def __init__(self, style_dict: dict | None = None):
+    def __init__(self, style_dict: dict | None = None, **kwargs):
         """Initialize the style.
 
         Args:
             style_dict: The style dictionary.
+            kwargs: Other key value pairs to apply to the dict update.
         """
+        if style_dict:
+            style_dict.update(kwargs)
+        else:
+            style_dict = kwargs
         style_dict, self._var_data = convert(style_dict or {})
         super().__init__(style_dict)
 
@@ -175,12 +180,15 @@ class Style(dict):
             style_dict: The style dictionary.
             kwargs: Other key value pairs to apply to the dict update.
         """
-        if kwargs:
-            style_dict = {**(style_dict or {}), **kwargs}
         if not isinstance(style_dict, Style):
             converted_dict = type(self)(style_dict)
         else:
             converted_dict = style_dict
+        if kwargs:
+            if converted_dict is None:
+                converted_dict = type(self)(kwargs)
+            else:
+                converted_dict.update(kwargs)
         # Combine our VarData with that of any Vars in the style_dict that was passed.
         self._var_data = VarData.merge(self._var_data, converted_dict._var_data)
         super().update(converted_dict)
@@ -274,3 +282,17 @@ def convert_dict_to_style_and_format_emotion(
 
     """
     return format_as_emotion(Style(raw_dict))
+
+
+STACK_CHILDREN_FULL_WIDTH = {
+    "& :where(.rx-Stack)": {
+        "width": "100%",
+    },
+    "& :where(.rx-Stack) > :where( "
+    "div:not(.rt-Box, .rx-Upload, .rx-Html),"
+    "input, select, textarea, table"
+    ")": {
+        "width": "100%",
+        "flex_shrink": "1",
+    },
+}

reflex/testing.py

@@ -1,4 +1,5 @@
 """reflex.testing - tools for testing reflex apps."""
+
 from __future__ import annotations
 
 import asyncio
@@ -42,7 +43,6 @@ import reflex.utils.prerequisites
 import reflex.utils.processes
 from reflex.state import (
     BaseState,
-    State,
     StateManagerMemory,
     StateManagerRedis,
     reload_state_module,
@@ -167,6 +167,8 @@ class AppHarness:
                 app_name = app_source.__name__
 
             app_name = app_name.lower()
+            while "__" in app_name:
+                app_name = app_name.replace("__", "_")
         return cls(
             app_name=app_name,
             app_source=app_source,
@@ -240,13 +242,15 @@ class AppHarness:
             # ensure config and app are reloaded when testing different app
             reflex.config.get_config(reload=True)
             # Save decorated pages before importing the test app module
-            before_decorated_pages = reflex.app.DECORATED_PAGES.copy()
+            before_decorated_pages = reflex.app.DECORATED_PAGES[self.app_name].copy()
             # Ensure the AppHarness test does not skip State assignment due to running via pytest
             os.environ.pop(reflex.constants.PYTEST_CURRENT_TEST, None)
             self.app_module = reflex.utils.prerequisites.get_compiled_app(reload=True)
             # Save the pages that were added during testing
             self._decorated_pages = [
-                p for p in reflex.app.DECORATED_PAGES if p not in before_decorated_pages
+                p
+                for p in reflex.app.DECORATED_PAGES[self.app_name]
+                if p not in before_decorated_pages
             ]
         self.app_instance = self.app_module.app
         if isinstance(self.app_instance._state_manager, StateManagerRedis):
@@ -411,7 +415,7 @@ class AppHarness:
 
         # Cleanup decorated pages added during testing
         for page in self._decorated_pages:
-            reflex.app.DECORATED_PAGES.remove(page)
+            reflex.app.DECORATED_PAGES[self.app_name].remove(page)
 
     def __exit__(self, *excinfo) -> None:
         """Contextmanager protocol for `stop()`.
@@ -536,7 +540,7 @@ class AppHarness:
         if driver_clz is None:
             requested_driver = os.environ.get("APP_HARNESS_DRIVER", "Chrome")
             driver_clz = getattr(webdriver, requested_driver)
-            options = webdriver.ChromeOptions()
+            options = getattr(webdriver, f"{requested_driver}Options")()
         if driver_clz is webdriver.Chrome and want_headless:
             options = webdriver.ChromeOptions()
             options.add_argument("--headless=new")
@@ -596,7 +600,7 @@ class AppHarness:
                 await self.state_manager.close()
 
     @contextlib.asynccontextmanager
-    async def modify_state(self, token: str) -> AsyncIterator[State]:
+    async def modify_state(self, token: str) -> AsyncIterator[BaseState]:
         """Modify the state associated with the given token and send update to frontend.
 
         Args:

reflex/utils/console.py

@@ -174,7 +174,9 @@ def ask(
     Returns:
         A string with the user input.
     """
-    return Prompt.ask(question, choices=choices, default=default, show_choices=show_choices)  # type: ignore
+    return Prompt.ask(
+        question, choices=choices, default=default, show_choices=show_choices
+    )  # type: ignore
 
 
 def progress():

reflex/utils/exec.py

@@ -73,11 +73,12 @@ def kill(proc_pid: int):
 # run_process_and_launch_url is assumed to be used
 # only to launch the frontend
 # If this is not the case, might have to change the logic
-def run_process_and_launch_url(run_command: list[str]):
+def run_process_and_launch_url(run_command: list[str], backend_present=True):
     """Run the process and launch the URL.
 
     Args:
         run_command: The command to run.
+        backend_present: Whether the backend is present.
     """
     from reflex.utils import processes
 
@@ -89,7 +90,7 @@ def run_process_and_launch_url(run_command: list[str]):
     while True:
         if process is None:
             kwargs = {}
-            if constants.IS_WINDOWS:
+            if constants.IS_WINDOWS and backend_present:
                 kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
             process = processes.new_process(
                 run_command,
@@ -122,12 +123,13 @@ def run_process_and_launch_url(run_command: list[str]):
             break  # while True
 
 
-def run_frontend(root: Path, port: str):
+def run_frontend(root: Path, port: str, backend_present=True):
     """Run the frontend.
 
     Args:
         root: The root path of the project.
         port: The port to run the frontend on.
+        backend_present: Whether the backend is present.
     """
     from reflex.utils import prerequisites
 
@@ -139,15 +141,19 @@ def run_frontend(root: Path, port: str):
     # Run the frontend in development mode.
     console.rule("[bold green]App Running")
     os.environ["PORT"] = str(get_config().frontend_port if port is None else port)
-    run_process_and_launch_url([prerequisites.get_package_manager(), "run", "dev"])  # type: ignore
+    run_process_and_launch_url(
+        [prerequisites.get_package_manager(), "run", "dev"],  # type: ignore
+        backend_present,
+    )
 
 
-def run_frontend_prod(root: Path, port: str):
+def run_frontend_prod(root: Path, port: str, backend_present=True):
     """Run the frontend.
 
     Args:
         root: The root path of the project (to keep same API as run_frontend).
         port: The port to run the frontend on.
+        backend_present: Whether the backend is present.
     """
     from reflex.utils import prerequisites
 
@@ -157,7 +163,10 @@ def run_frontend_prod(root: Path, port: str):
     prerequisites.validate_frontend_dependencies(init=False)
     # Run the frontend in production mode.
     console.rule("[bold green]App Running")
-    run_process_and_launch_url([prerequisites.get_package_manager(), "run", "prod"])  # type: ignore
+    run_process_and_launch_url(
+        [prerequisites.get_package_manager(), "run", "prod"],  # type: ignore
+        backend_present,
+    )
 
 
 def run_backend(
@@ -271,7 +280,11 @@ def output_system_info():
 
     system = platform.system()
 
-    if system != "Windows":
+    if (
+        system != "Windows"
+        or system == "Windows"
+        and prerequisites.is_windows_bun_supported()
+    ):
         dependencies.extend(
             [
                 f"[FNM {prerequisites.get_fnm_version()} (Expected: {constants.Fnm.VERSION}) (PATH: {constants.Fnm.EXE})]",

reflex/utils/format.py

@@ -330,7 +330,7 @@ def format_cond(
     cond = f"isTrue({cond})"
 
     def create_var(cond_part):
-        return Var.create_safe(cond_part, _var_is_string=type(cond_part) is str)
+        return Var.create_safe(cond_part, _var_is_string=isinstance(cond_part, str))
 
     # Format prop conds.
     if is_prop:

reflex/utils/imports.py

@@ -66,7 +66,9 @@ class ImportVar(Base):
             The name(tag name with alias) of tag.
         """
         if self.alias:
-            return self.alias if self.is_default else " as ".join([self.tag, self.alias])  # type: ignore
+            return (
+                self.alias if self.is_default else " as ".join([self.tag, self.alias])  # type: ignore
+            )
         else:
             return self.tag or ""