reflex 0.4.5a1__py3-none-any.whl → 0.4.6__py3-none-any.whl

reflex/event.py

@@ -1,19 +1,20 @@
 """Define event classes to connect the frontend and backend."""
+
 from __future__ import annotations
 
 import inspect
 from base64 import b64encode
 from types import FunctionType
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
     List,
     Optional,
     Tuple,
-    Type,
     Union,
+    _GenericAlias,  # type: ignore
+    get_type_hints,
 )
 
 from reflex import constants
@@ -22,9 +23,6 @@ from reflex.utils import console, format
 from reflex.utils.types import ArgsSpec
 from reflex.vars import BaseVar, Var
 
-if TYPE_CHECKING:
-    from reflex.state import BaseState
-
 
 class Event(Base):
     """An event that describes any state change in the app."""
@@ -74,44 +72,6 @@ def background(fn):
     return fn
 
 
-def _no_chain_background_task(
-    state_cls: Type["BaseState"], name: str, fn: Callable
-) -> Callable:
-    """Protect against directly chaining a background task from another event handler.
-
-    Args:
-        state_cls: The state class that the event handler is in.
-        name: The name of the background task.
-        fn: The background task coroutine function / generator.
-
-    Returns:
-        A compatible coroutine function / generator that raises a runtime error.
-
-    Raises:
-        TypeError: If the background task is not async.
-    """
-    call = f"{state_cls.__name__}.{name}"
-    message = (
-        f"Cannot directly call background task {name!r}, use "
-        f"`yield {call}` or `return {call}` instead."
-    )
-    if inspect.iscoroutinefunction(fn):
-
-        async def _no_chain_background_task_co(*args, **kwargs):
-            raise RuntimeError(message)
-
-        return _no_chain_background_task_co
-    if inspect.isasyncgenfunction(fn):
-
-        async def _no_chain_background_task_gen(*args, **kwargs):
-            yield
-            raise RuntimeError(message)
-
-        return _no_chain_background_task_gen
-
-    raise TypeError(f"{fn} is marked as a background task, but is not async.")
-
-
 class EventActionsMixin(Base):
     """Mixin for DOM event actions."""
 
@@ -148,7 +108,7 @@ class EventHandler(EventActionsMixin):
     fn: Any
 
     # The full name of the state class this event handler is attached to.
-    # Emtpy string means this event handler is a server side event.
+    # Empty string means this event handler is a server side event.
     state_full_name: str = ""
 
     class Config:
@@ -157,6 +117,21 @@ class EventHandler(EventActionsMixin):
         # Needed to allow serialization of Callable.
         frozen = True
 
+    @classmethod
+    def __class_getitem__(cls, args_spec: str) -> _GenericAlias:
+        """Get a typed EventHandler.
+
+        Args:
+            args_spec: The args_spec of the EventHandler.
+
+        Returns:
+            The EventHandler class item.
+        """
+        gen = _GenericAlias(cls, Any)
+        # Cannot subclass special typing classes, so we need to set the args_spec dynamically as an attribute.
+        gen.args_spec = args_spec
+        return gen
+
     @property
     def is_background(self) -> bool:
         """Whether the event handler is a background task.
@@ -324,7 +299,7 @@ class FileUpload(Base):
     on_upload_progress: Optional[Union[EventHandler, Callable]] = None
 
     @staticmethod
-    def on_upload_progress_args_spec(_prog: dict[str, int | float | bool]):
+    def on_upload_progress_args_spec(_prog: Dict[str, Union[int, float, bool]]):
         """Args spec for on_upload_progress event handler.
 
         Returns:
@@ -485,6 +460,20 @@ def set_focus(ref: str) -> EventSpec:
     )
 
 
+def scroll_to(elem_id: str) -> EventSpec:
+    """Select the id of a html element for scrolling into view.
+
+    Args:
+        elem_id: the id of the element
+
+    Returns:
+        An EventSpec to scroll the page to the selected element.
+    """
+    js_code = f"document.getElementById('{elem_id}').scrollIntoView();"
+
+    return call_script(js_code)
+
+
 def set_value(ref: str, value: Any) -> EventSpec:
     """Set the value of a ref.
 
@@ -771,11 +760,12 @@ def parse_args_spec(arg_spec: ArgsSpec):
         The parsed args.
     """
     spec = inspect.getfullargspec(arg_spec)
+    annotations = get_type_hints(arg_spec)
     return arg_spec(
         *[
             BaseVar(
                 _var_name=f"_{l_arg}",
-                _var_type=spec.annotations.get(l_arg, FrontendEvent),
+                _var_type=annotations.get(l_arg, FrontendEvent),
                 _var_is_local=True,
             )
             for l_arg in spec.args

reflex/reflex.py

@@ -169,10 +169,10 @@ def _run(
 
     # If something is running on the ports, ask the user if they want to kill or change it.
     if frontend and processes.is_process_on_port(frontend_port):
-        frontend_port = processes.change_or_terminate_port(frontend_port, "frontend")
+        frontend_port = processes.change_port(frontend_port, "frontend")
 
     if backend and processes.is_process_on_port(backend_port):
-        backend_port = processes.change_or_terminate_port(backend_port, "backend")
+        backend_port = processes.change_port(backend_port, "backend")
 
     # Apply the new ports to the config.
     if frontend_port != str(config.frontend_port):
@@ -300,22 +300,14 @@ def export(
     )
 
 
-@cli.command()
-def login(
-    loglevel: constants.LogLevel = typer.Option(
-        config.loglevel, help="The log level to use."
-    ),
-):
-    """Authenticate with Reflex hosting service."""
+def _login() -> str:
+    """Helper function to authenticate with Reflex hosting service."""
     from reflex_cli.utils import hosting
 
-    # Set the log level.
-    console.set_log_level(loglevel)
-
     access_token, invitation_code = hosting.authenticated_token()
     if access_token:
         console.print("You already logged in.")
-        return
+        return access_token
 
     # If not already logged in, open a browser window/tab to the login page.
     access_token = hosting.authenticate_on_browser(invitation_code)
@@ -325,6 +317,20 @@ def login(
         raise typer.Exit(1)
 
     console.print("Successfully logged in.")
+    return access_token
+
+
+@cli.command()
+def login(
+    loglevel: constants.LogLevel = typer.Option(
+        config.loglevel, help="The log level to use."
+    ),
+):
+    """Authenticate with Reflex hosting service."""
+    # Set the log level.
+    console.set_log_level(loglevel)
+
+    _login()
 
 
 @cli.command()

reflex/state.py

@@ -15,6 +15,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from types import FunctionType, MethodType
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncIterator,
     Callable,
@@ -27,8 +28,19 @@ from typing import (
     Type,
 )
 
-import cloudpickle
-import pydantic
+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
+except ModuleNotFoundError:
+    import pydantic
+
 import wrapt
 from redis.asyncio import Redis
 
@@ -38,7 +50,6 @@ from reflex.event import (
     Event,
     EventHandler,
     EventSpec,
-    _no_chain_background_task,
     fix_events,
     window_alert,
 )
@@ -48,10 +59,18 @@ from reflex.utils.exec import is_testing_env
 from reflex.utils.serializers import SerializedType, serialize, serializer
 from reflex.vars import BaseVar, ComputedVar, Var, computed_var
 
+if TYPE_CHECKING:
+    from reflex.components.component import Component
+
+
 Delta = Dict[str, Any]
 var = computed_var
 
 
+# If the state is this large, it's considered a performance issue.
+TOO_LARGE_SERIALIZED_STATE = 100 * 1024  # 100kb
+
+
 class HeaderData(Base):
     """An object containing headers data."""
 
@@ -145,6 +164,44 @@ class RouterData(Base):
         self.page = PageData(router_data)
 
 
+def _no_chain_background_task(
+    state_cls: Type["BaseState"], name: str, fn: Callable
+) -> Callable:
+    """Protect against directly chaining a background task from another event handler.
+
+    Args:
+        state_cls: The state class that the event handler is in.
+        name: The name of the background task.
+        fn: The background task coroutine function / generator.
+
+    Returns:
+        A compatible coroutine function / generator that raises a runtime error.
+
+    Raises:
+        TypeError: If the background task is not async.
+    """
+    call = f"{state_cls.__name__}.{name}"
+    message = (
+        f"Cannot directly call background task {name!r}, use "
+        f"`yield {call}` or `return {call}` instead."
+    )
+    if inspect.iscoroutinefunction(fn):
+
+        async def _no_chain_background_task_co(*args, **kwargs):
+            raise RuntimeError(message)
+
+        return _no_chain_background_task_co
+    if inspect.isasyncgenfunction(fn):
+
+        async def _no_chain_background_task_gen(*args, **kwargs):
+            yield
+            raise RuntimeError(message)
+
+        return _no_chain_background_task_gen
+
+    raise TypeError(f"{fn} is marked as a background task, but is not async.")
+
+
 RESERVED_BACKEND_VAR_NAMES = {
     "_backend_vars",
     "_computed_var_dependencies",
@@ -290,8 +347,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                     parent_state=self,
                     _reflex_internal_init=True,
                 )
-        # Convert the event handlers to functions.
-        self._init_event_handlers()
 
         # Create a fresh copy of the backend variables for this instance
         self._backend_vars = copy.deepcopy(
@@ -302,32 +357,6 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             }
         )
 
-    def _init_event_handlers(self, state: BaseState | None = None):
-        """Initialize event handlers.
-
-        Allow event handlers to be called directly on the instance. This is
-        called recursively for all parent states.
-
-        Args:
-            state: The state to initialize the event handlers on.
-        """
-        if state is None:
-            state = self
-
-        # Convert the event handlers to functions.
-        for name, event_handler in state.event_handlers.items():
-            if event_handler.is_background:
-                fn = _no_chain_background_task(type(state), name, event_handler.fn)
-            else:
-                fn = functools.partial(event_handler.fn, self)
-            fn.__module__ = event_handler.fn.__module__  # type: ignore
-            fn.__qualname__ = event_handler.fn.__qualname__  # type: ignore
-            setattr(self, name, fn)
-
-        # Also allow direct calling of parent state event handlers
-        if state.parent_state is not None:
-            self._init_event_handlers(state.parent_state)
-
     def __repr__(self) -> str:
         """Get the string representation of the state.
 
@@ -1033,12 +1062,31 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             if parent_state is not None:
                 return getattr(parent_state, name)
 
+        # Allow event handlers to be called on the instance directly.
+        event_handlers = super().__getattribute__("event_handlers")
+        if name in event_handlers:
+            handler = event_handlers[name]
+            if handler.is_background:
+                fn = _no_chain_background_task(type(self), name, handler.fn)
+            else:
+                fn = functools.partial(handler.fn, self)
+            fn.__module__ = handler.fn.__module__  # type: ignore
+            fn.__qualname__ = handler.fn.__qualname__  # type: ignore
+            return fn
+
         backend_vars = super().__getattribute__("_backend_vars")
         if name in backend_vars:
             value = backend_vars[name]
         else:
             value = super().__getattribute__(name)
 
+        if isinstance(value, EventHandler):
+            # The event handler is inherited from a parent, so let the parent convert
+            # it to a callable function.
+            parent_state = super().__getattribute__("parent_state")
+            if parent_state is not None:
+                return getattr(parent_state, name)
+
         if isinstance(value, MutableProxy.__mutable_types__) and (
             name in super().__getattribute__("base_vars") or name in backend_vars
         ):
@@ -1184,9 +1232,9 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         # Determine which parent states to fetch from the common ancestor down to the target_state_cls.
         fetch_parent_states = [common_ancestor_name]
-        for ix, relative_parent_state_name in enumerate(relative_target_state_parts):
+        for relative_parent_state_name in relative_target_state_parts:
             fetch_parent_states.append(
-                ".".join([*fetch_parent_states[: ix + 1], relative_parent_state_name])
+                ".".join((fetch_parent_states[-1], relative_parent_state_name))
             )
 
         return common_ancestor_name, fetch_parent_states[1:-1]
@@ -1230,9 +1278,18 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         ) = self._determine_missing_parent_states(target_state_cls)
 
         # Fetch all missing parent states and link them up to the common ancestor.
-        parent_states_by_name = dict(self._get_parent_states())
+        parent_states_tuple = self._get_parent_states()
+        root_state = parent_states_tuple[-1][1]
+        parent_states_by_name = dict(parent_states_tuple)
         parent_state = parent_states_by_name[common_ancestor_name]
         for parent_state_name in missing_parent_states:
+            try:
+                parent_state = root_state.get_substate(parent_state_name.split("."))
+                # The requested state is already cached, do NOT fetch it again.
+                continue
+            except ValueError:
+                # The requested state is missing, fetch from redis.
+                pass
             parent_state = await state_manager.get_state(
                 token=_substate_key(
                     self.router.session.client_token, parent_state_name
@@ -1787,11 +1844,9 @@ class OnLoadInternalState(State):
         # 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 and self.is_hydrated:
-            return  # Fast path for page-to-page navigation
         if not load_events:
             self.is_hydrated = True
-            return  # Fast path for initial hydrate with no on_load events defined.
+            return  # Fast path for navigation with no on_load events defined.
         self.is_hydrated = False
         return [
             *fix_events(
@@ -1803,6 +1858,45 @@ class OnLoadInternalState(State):
         ]
 
 
+class ComponentState(Base):
+    """The base class for a State that is copied for each Component associated with it."""
+
+    _per_component_state_instance_count: ClassVar[int] = 0
+
+    @classmethod
+    def get_component(cls, *children, **props) -> "Component":
+        """Get the component instance.
+
+        Args:
+            children: The children of the component.
+            props: The props of the component.
+
+        Raises:
+            NotImplementedError: if the subclass does not override this method.
+        """
+        raise NotImplementedError(
+            f"{cls.__name__} must implement get_component to return the component instance."
+        )
+
+    @classmethod
+    def create(cls, *children, **props) -> "Component":
+        """Create a new instance of the Component.
+
+        Args:
+            children: The children of the component.
+            props: The props of the component.
+
+        Returns:
+            A new instance of the Component with an independent copy of the State.
+        """
+        cls._per_component_state_instance_count += 1
+        state_cls_name = f"{cls.__name__}_n{cls._per_component_state_instance_count}"
+        component_state = type(state_cls_name, (cls, State), {})
+        component = component_state.get_component(*children, **props)
+        component.State = component_state
+        return component
+
+
 class StateProxy(wrapt.ObjectProxy):
     """Proxy of a state instance to control mutability of vars for a background task.
 
@@ -2155,6 +2249,25 @@ class StateManagerMemory(StateManager):
             await self.set_state(token, state)
 
 
+# Workaround https://github.com/cloudpipe/cloudpickle/issues/408 for dynamic pydantic classes
+if not isinstance(State.validate.__func__, FunctionType):
+    cython_function_or_method = type(State.validate.__func__)
+
+    @dill.register(cython_function_or_method)
+    def _dill_reduce_cython_function_or_method(pickler, obj):
+        # Ignore cython function when pickling.
+        pass
+
+
+@dill.register(type(State))
+def _dill_reduce_state(pickler, obj):
+    if obj is not State and issubclass(obj, State):
+        # Avoid serializing subclasses of State, instead get them by reference from the State class.
+        pickler.save_reduce(State.get_class_substate, (obj.get_full_name(),), obj=obj)
+    else:
+        dill.Pickler.dispatch[type](pickler, obj)
+
+
 class StateManagerRedis(StateManager):
     """A state manager that stores states in redis."""
 
@@ -2183,6 +2296,9 @@ class StateManagerRedis(StateManager):
         b"evicted",
     }
 
+    # Only warn about each state class size once.
+    _warned_about_state_size: ClassVar[Set[str]] = set()
+
     def _get_root_state(self, state: BaseState) -> BaseState:
         """Chase parent_state pointers to find an instance of the top-level state.
 
@@ -2294,7 +2410,7 @@ class StateManagerRedis(StateManager):
 
         if redis_state is not None:
             # Deserialize the substate.
-            state = cloudpickle.loads(redis_state)
+            state = dill.loads(redis_state)
 
             # Populate parent state if missing and requested.
             if parent_state is None:
@@ -2334,6 +2450,29 @@ class StateManagerRedis(StateManager):
             return self._get_root_state(state)
         return state
 
+    def _warn_if_too_large(
+        self,
+        state: BaseState,
+        pickle_state_size: int,
+    ):
+        """Print a warning when the state is too large.
+
+        Args:
+            state: The state to check.
+            pickle_state_size: The size of the pickled state.
+        """
+        state_full_name = state.get_full_name()
+        if (
+            state_full_name not in self._warned_about_state_size
+            and pickle_state_size > TOO_LARGE_SERIALIZED_STATE
+            and state.substates
+        ):
+            console.warn(
+                f"State {state_full_name} serializes to {pickle_state_size} bytes "
+                "which may present performance issues. Consider reducing the size of this state."
+            )
+            self._warned_about_state_size.add(state_full_name)
+
     async def set_state(
         self,
         token: str,
@@ -2382,9 +2521,11 @@ class StateManagerRedis(StateManager):
             )
         # Persist only the given state (parents or substates are excluded by BaseState.__getstate__).
         if state._get_was_touched():
+            pickle_state = dill.dumps(state, byref=True)
+            self._warn_if_too_large(state, len(pickle_state))
             await self.redis.set(
                 _substate_key(client_token, state),
-                cloudpickle.dumps(state),
+                pickle_state,
                 ex=self.token_expiration,
             )
 
@@ -2944,8 +3085,12 @@ def reload_state_module(
     Args:
         module: The module to reload.
         state: Recursive argument for the state class to reload.
+
     """
     for subclass in tuple(state.class_subclasses):
         reload_state_module(module=module, state=subclass)
         if subclass.__module__ == module and module is not None:
             state.class_subclasses.remove(subclass)
+            state._always_dirty_substates.discard(subclass.get_name())
+    state._init_var_dependency_dicts()
+    state.get_class_substate.cache_clear()

reflex/testing.py

@@ -40,7 +40,13 @@ import reflex.utils.build
 import reflex.utils.exec
 import reflex.utils.prerequisites
 import reflex.utils.processes
-from reflex.state import BaseState, State, StateManagerMemory, StateManagerRedis
+from reflex.state import (
+    BaseState,
+    State,
+    StateManagerMemory,
+    StateManagerRedis,
+    reload_state_module,
+)
 
 try:
     from selenium import webdriver  # pyright: ignore [reportMissingImports]
@@ -67,16 +73,13 @@ FRONTEND_POPEN_ARGS = {}
 T = TypeVar("T")
 TimeoutType = Optional[Union[int, float]]
 
-if platform.system == "Windows":
+if platform.system() == "Windows":
     FRONTEND_POPEN_ARGS["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
+    FRONTEND_POPEN_ARGS["shell"] = True
 else:
     FRONTEND_POPEN_ARGS["start_new_session"] = True
 
 
-# Save a copy of internal substates to reset after each test.
-INTERNAL_STATES = State.class_subclasses.copy()
-
-
 # borrowed from py3.11
 class chdir(contextlib.AbstractContextManager):
     """Non thread-safe context manager to change the current working directory."""
@@ -229,11 +232,6 @@ class AppHarness:
             reflex.config.get_config(reload=True)
             # Clean out any `rx.page` decorators from other tests.
             reflex.app.DECORATED_PAGES.clear()
-            # reset rx.State subclasses
-            State.class_subclasses.clear()
-            State.class_subclasses.update(INTERNAL_STATES)
-            State._always_dirty_substates = set()
-            State.get_class_substate.cache_clear()
             # 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)
@@ -244,6 +242,10 @@ class AppHarness:
         else:
             self.state_manager = self.app_instance._state_manager
 
+    def _reload_state_module(self):
+        """Reload the rx.State module to avoid conflict when reloading."""
+        reload_state_module(module=f"{self.app_name}.{self.app_name}")
+
     def _get_backend_shutdown_handler(self):
         if self.backend is None:
             raise RuntimeError("Backend was not initialized.")
@@ -361,6 +363,8 @@ class AppHarness:
 
     def stop(self) -> None:
         """Stop the frontend and backend servers."""
+        self._reload_state_module()
+
         if self.backend is not None:
             self.backend.should_exit = True
         if self.frontend_process is not None:

reflex/utils/console.py

@@ -16,6 +16,9 @@ _console = Console()
 # The current log level.
 _LOG_LEVEL = LogLevel.INFO
 
+# Deprecated features who's warning has been printed.
+_EMITTED_DEPRECATION_WARNINGS = set()
+
 
 def set_log_level(log_level: LogLevel):
     """Set the log level.
@@ -111,6 +114,7 @@ def deprecate(
     reason: str,
     deprecation_version: str,
     removal_version: str,
+    dedupe: bool = True,
     **kwargs,
 ):
     """Print a deprecation warning.
@@ -119,15 +123,19 @@ def deprecate(
         feature_name: The feature to deprecate.
         reason: The reason for deprecation.
         deprecation_version: The version the feature was deprecated
-        removal_version: The version the deprecated feature will be removed.
+        removal_version: The version the deprecated feature will be removed
+        dedupe: If True, suppress multiple console logs of deprecation message.
         kwargs: Keyword arguments to pass to the print function.
     """
-    msg = (
-        f"{feature_name} has been deprecated in version {deprecation_version} {reason.rstrip('.')}. It will be completely "
-        f"removed in {removal_version}"
-    )
-    if _LOG_LEVEL <= LogLevel.WARNING:
-        print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
+    if feature_name not in _EMITTED_DEPRECATION_WARNINGS:
+        msg = (
+            f"{feature_name} has been deprecated in version {deprecation_version} {reason.rstrip('.')}. It will be completely "
+            f"removed in {removal_version}"
+        )
+        if _LOG_LEVEL <= LogLevel.WARNING:
+            print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
+        if dedupe:
+            _EMITTED_DEPRECATION_WARNINGS.add(feature_name)
 
 
 def error(msg: str, **kwargs):

reflex/utils/exec.py

@@ -307,3 +307,12 @@ def is_prod_mode() -> bool:
         constants.Env.DEV.value,
     )
     return current_mode == constants.Env.PROD.value
+
+
+def should_skip_compile() -> bool:
+    """Whether the app should skip compile.
+
+    Returns:
+        True if the app should skip compile.
+    """
+    return os.environ.get(constants.SKIP_COMPILE_ENV_VAR) == "yes"