reflex 0.7.1a4__py3-none-any.whl → 0.7.2a2__py3-none-any.whl

reflex/istate/data.py

@@ -1,7 +1,6 @@
 """This module contains the dataclasses representing the router object."""
 
 import dataclasses
-from typing import Optional
 
 from reflex import constants
 from reflex.utils import format
@@ -25,7 +24,7 @@ class HeaderData:
     accept_encoding: str = ""
     accept_language: str = ""
 
-    def __init__(self, router_data: Optional[dict] = None):
+    def __init__(self, router_data: dict | None = None):
         """Initialize the HeaderData object based on router_data.
 
         Args:
@@ -50,7 +49,7 @@ class PageData:
     full_raw_path: str = ""
     params: dict = dataclasses.field(default_factory=dict)
 
-    def __init__(self, router_data: Optional[dict] = None):
+    def __init__(self, router_data: dict | None = None):
         """Initialize the PageData object based on router_data.
 
         Args:
@@ -90,7 +89,7 @@ class SessionData:
     client_ip: str = ""
     session_id: str = ""
 
-    def __init__(self, router_data: Optional[dict] = None):
+    def __init__(self, router_data: dict | None = None):
         """Initialize the SessionData object based on router_data.
 
         Args:
@@ -115,7 +114,7 @@ class RouterData:
     headers: HeaderData = dataclasses.field(default_factory=HeaderData)
     page: PageData = dataclasses.field(default_factory=PageData)
 
-    def __init__(self, router_data: Optional[dict] = None):
+    def __init__(self, router_data: dict | None = None):
         """Initialize the RouterData object.
 
         Args:

reflex/middleware/hydrate_middleware.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from reflex import constants
 from reflex.event import Event, get_hydrate_event
@@ -20,7 +20,7 @@ class HydrateMiddleware(Middleware):
 
     async def preprocess(
         self, app: App, state: BaseState, event: Event
-    ) -> Optional[StateUpdate]:
+    ) -> StateUpdate | None:
         """Preprocess the event.
 
         Args:

reflex/middleware/middleware.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from reflex.event import Event
 from reflex.state import BaseState, StateUpdate
@@ -18,7 +18,7 @@ class Middleware(ABC):
     @abstractmethod
     async def preprocess(
         self, app: App, state: BaseState, event: Event
-    ) -> Optional[StateUpdate]:
+    ) -> StateUpdate | None:
         """Preprocess the event.
 
         Args:

reflex/model.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import re
 from collections import defaultdict
 from contextlib import suppress
-from typing import Any, ClassVar, Optional, Type, Union
+from typing import Any, ClassVar, Type
 
 import alembic.autogenerate
 import alembic.command
@@ -161,9 +161,7 @@ async def get_db_status() -> dict[str, bool]:
     return {"db": status}
 
 
-SQLModelOrSqlAlchemy = Union[
-    Type[sqlmodel.SQLModel], Type[sqlalchemy.orm.DeclarativeBase]
-]
+SQLModelOrSqlAlchemy = Type[sqlmodel.SQLModel] | Type[sqlalchemy.orm.DeclarativeBase]
 
 
 class ModelRegistry:
@@ -247,7 +245,7 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
     """Base class to define a table in the database."""
 
     # The primary key for the table.
-    id: Optional[int] = sqlmodel.Field(default=None, primary_key=True)
+    id: int | None = sqlmodel.Field(default=None, primary_key=True)
 
     def __init_subclass__(cls):
         """Drop the default primary key field if any primary key field is defined."""

reflex/page.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, List
 
 from reflex.config import get_config
 from reflex.event import EventType
 
-DECORATED_PAGES: Dict[str, List] = defaultdict(list)
+DECORATED_PAGES: dict[str, List] = defaultdict(list)
 
 
 def page(

reflex/reflex.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import atexit
 from pathlib import Path
-from typing import List, Optional
 
 import typer
 import typer.core
@@ -477,23 +476,23 @@ def deploy(
         "--app-id",
         help="The ID of the App to deploy over.",
     ),
-    regions: List[str] = typer.Option(
+    regions: list[str] = typer.Option(
         [],
         "-r",
         "--region",
         help="The regions to deploy to. `reflex cloud regions` For multiple envs, repeat this option, e.g. --region sjc --region iad",
     ),
-    envs: List[str] = typer.Option(
+    envs: list[str] = typer.Option(
         [],
         "--env",
         help="The environment variables to set: <key>=<value>. For multiple envs, repeat this option, e.g. --env k1=v2 --env k2=v2.",
     ),
-    vmtype: Optional[str] = typer.Option(
+    vmtype: str | None = typer.Option(
         None,
         "--vmtype",
         help="Vm type id. Run `reflex cloud vmtypes` to get options.",
     ),
-    hostname: Optional[str] = typer.Option(
+    hostname: str | None = typer.Option(
         None,
         "--hostname",
         help="The hostname of the frontend.",
@@ -502,7 +501,7 @@ def deploy(
         True,
         help="Whether to list configuration options and ask for confirmation.",
     ),
-    envfile: Optional[str] = typer.Option(
+    envfile: str | None = typer.Option(
         None,
         "--envfile",
         help="The path to an env file to use. Will override any envs set manually.",
@@ -510,22 +509,22 @@ def deploy(
     loglevel: constants.LogLevel = typer.Option(
         config.loglevel, help="The log level to use."
     ),
-    project: Optional[str] = typer.Option(
+    project: str | None = typer.Option(
         None,
         "--project",
         help="project id to deploy to",
     ),
-    project_name: Optional[str] = typer.Option(
+    project_name: str | None = typer.Option(
         None,
         "--project-name",
         help="The name of the project to deploy to.",
     ),
-    token: Optional[str] = typer.Option(
+    token: str | None = typer.Option(
         None,
         "--token",
         help="token to use for auth",
     ),
-    config_path: Optional[str] = typer.Option(
+    config_path: str | None = typer.Option(
         None,
         "--config",
         help="path to the config file",

reflex/state.py

@@ -14,6 +14,7 @@ import sys
 import time
 import typing
 import uuid
+import warnings
 from abc import ABC, abstractmethod
 from hashlib import md5
 from pathlib import Path
@@ -26,7 +27,6 @@ from typing import (
     Callable,
     ClassVar,
     Dict,
-    List,
     Optional,
     Sequence,
     Set,
@@ -34,7 +34,6 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
-    Union,
     cast,
     get_args,
     get_type_hints,
@@ -90,9 +89,9 @@ from reflex.utils.serializers import serializer
 from reflex.utils.types import (
     _isinstance,
     get_origin,
-    is_optional,
     is_union,
     override,
+    true_type_for_pydantic_field,
     value_inside_optional,
 )
 from reflex.vars import VarData
@@ -110,7 +109,7 @@ if TYPE_CHECKING:
     from reflex.components.component import Component
 
 
-Delta = Dict[str, Any]
+Delta = dict[str, Any]
 var = computed_var
 
 
@@ -118,7 +117,7 @@ if environment.REFLEX_PERF_MODE.get() != PerformanceMode.OFF:
     # If the state is this large, it's considered a performance issue.
     TOO_LARGE_SERIALIZED_STATE = environment.REFLEX_STATE_SIZE_LIMIT.get() * 1024
     # Only warn about each state class size once.
-    _WARNED_ABOUT_STATE_SIZE: Set[str] = set()
+    _WARNED_ABOUT_STATE_SIZE: set[str] = set()
 
 # Errors caught during pickling of state
 HANDLED_PICKLE_ERRORS = (
@@ -273,7 +272,11 @@ class EventHandlerSetVar(EventHandler):
         return super().__call__(*args)
 
 
-def _unwrap_field_type(type_: Type) -> Type:
+if TYPE_CHECKING:
+    from pydantic.v1.fields import ModelField
+
+
+def _unwrap_field_type(type_: types.GenericType) -> Type:
     """Unwrap rx.Field type annotations.
 
     Args:
@@ -304,7 +307,7 @@ def get_var_for_field(cls: Type[BaseState], f: ModelField):
     return dispatch(
         field_name=field_name,
         var_data=VarData.from_state(cls, f.name),
-        result_var_type=_unwrap_field_type(f.outer_type_),
+        result_var_type=_unwrap_field_type(true_type_for_pydantic_field(f)),
     )
 
 
@@ -355,31 +358,31 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
     event_handlers: ClassVar[Dict[str, EventHandler]] = {}
 
     # A set of subclassses of this class.
-    class_subclasses: ClassVar[Set[Type[BaseState]]] = set()
+    class_subclasses: ClassVar[set[Type[BaseState]]] = set()
 
     # Mapping of var name to set of (state_full_name, var_name) that depend on it.
-    _var_dependencies: ClassVar[Dict[str, Set[Tuple[str, str]]]] = {}
+    _var_dependencies: ClassVar[Dict[str, set[tuple[str, str]]]] = {}
 
     # Set of vars which always need to be recomputed
-    _always_dirty_computed_vars: ClassVar[Set[str]] = set()
+    _always_dirty_computed_vars: ClassVar[set[str]] = set()
 
     # Set of substates which always need to be recomputed
-    _always_dirty_substates: ClassVar[Set[str]] = set()
+    _always_dirty_substates: ClassVar[set[str]] = set()
 
     # Set of states which might need to be recomputed if vars in this state change.
-    _potentially_dirty_states: ClassVar[Set[str]] = set()
+    _potentially_dirty_states: ClassVar[set[str]] = set()
 
     # The parent state.
-    parent_state: Optional[BaseState] = None
+    parent_state: BaseState | None = None
 
     # The substates of the state.
     substates: Dict[str, BaseState] = {}
 
     # The set of dirty vars.
-    dirty_vars: Set[str] = set()
+    dirty_vars: set[str] = set()
 
     # The set of dirty substates.
-    dirty_substates: Set[str] = set()
+    dirty_substates: set[str] = set()
 
     # The routing path that triggered the state
     router_data: Dict[str, Any] = {}
@@ -670,9 +673,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         )
 
     @classmethod
-    def _evaluate(
-        cls, f: Callable[[Self], Any], of_type: Union[type, None] = None
-    ) -> Var:
+    def _evaluate(cls, f: Callable[[Self], Any], of_type: type | None = None) -> Var:
         """Evaluate a function to a ComputedVar. Experimental.
 
         Args:
@@ -695,7 +696,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         def computed_var_func(state: Self):
             result = f(state)
 
-            if not _isinstance(result, of_type):
+            if not _isinstance(result, of_type, nested=1, treat_var_as_type=False):
                 console.warn(
                     f"Inline ComputedVar {f} expected type {of_type}, got {type(result)}. "
                     "You can specify expected type with `of_type` argument."
@@ -712,7 +713,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         return getattr(cls, unique_var_name)
 
     @classmethod
-    def _mixins(cls) -> List[Type]:
+    def _mixins(cls) -> list[Type]:
         """Get the mixin classes of the state.
 
         Returns:
@@ -1199,7 +1200,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             return inner_func
 
         def arglist_factory(param: str):
-            def inner_func(self: BaseState) -> List[str]:
+            def inner_func(self: BaseState) -> list[str]:
                 return self.router.page.params.get(param, [])
 
             return inner_func
@@ -1353,10 +1354,8 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         if name in fields:
             field = fields[name]
-            field_type = _unwrap_field_type(field.outer_type_)
-            if field.allow_none and not is_optional(field_type):
-                field_type = Union[field_type, None]
-            if not _isinstance(value, field_type):
+            field_type = _unwrap_field_type(true_type_for_pydantic_field(field))
+            if not _isinstance(value, field_type, nested=1, treat_var_as_type=False):
                 console.error(
                     f"Expected field '{type(self).__name__}.{name}' to receive type '{field_type}',"
                     f" but got '{value}' of type '{type(value)}'."
@@ -1645,14 +1644,26 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         if events is None or _is_valid_type(events):
             return events
+
+        if not isinstance(events, Sequence):
+            events = [events]
+
         try:
             if all(_is_valid_type(e) for e in events):
                 return events
         except TypeError:
             pass
 
+        coroutines = [e for e in events if asyncio.iscoroutine(e)]
+
+        for coroutine in coroutines:
+            coroutine_name = coroutine.__qualname__
+            warnings.filterwarnings(
+                "ignore", message=f"coroutine '{coroutine_name}' was never awaited"
+            )
+
         raise TypeError(
-            f"Your handler {handler.fn.__qualname__} must only return/yield: None, Events or other EventHandlers referenced by their class (not using `self`)"
+            f"Your handler {handler.fn.__qualname__} must only return/yield: None, Events or other EventHandlers referenced by their class (i.e. using `type(self)` or other class references)."
         )
 
     async def _as_state_update(
@@ -1702,7 +1713,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
                 return StateUpdate()
 
             event_specs_correct_type = cast(
-                Union[List[Union[EventSpec, EventHandler]], None],
+                list[EventSpec | EventHandler] | None,
                 [event_specs] if isinstance(event_specs, EventSpec) else event_specs,
             )
             fixed_events = fix_events(
@@ -1911,7 +1922,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             self.dirty_vars.intersection(frontend_computed_vars)
         )
 
-        subdelta: Dict[str, Any] = {
+        subdelta: dict[str, Any] = {
             prop: self.get_value(prop)
             for prop in delta_vars
             if not types.is_backend_base_variable(prop, type(self))
@@ -2150,7 +2161,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         def _field_tuple(
             field_name: str,
-        ) -> Tuple[str, str, Any, Union[bool, None], Any]:
+        ) -> tuple[str, str, Any, bool | None, Any]:
             model_field = cls.__fields__[field_name]
             return (
                 field_name,
@@ -2357,7 +2368,7 @@ class OnLoadInternalState(State):
         self.is_hydrated = False
         return [
             *fix_events(
-                cast(list[Union[EventSpec, EventHandler]], load_events),
+                cast(list[EventSpec | EventHandler], load_events),
                 self.router.session.client_token,
                 router_data=self.router_data,
             ),
@@ -2760,7 +2771,7 @@ class StateUpdate:
     delta: Delta = dataclasses.field(default_factory=dict)
 
     # Events to be added to the event queue.
-    events: List[Event] = dataclasses.field(default_factory=list)
+    events: list[Event] = dataclasses.field(default_factory=list)
 
     # Whether this is the final state update for the event.
     final: bool = True
@@ -2855,13 +2866,13 @@ class StateManagerMemory(StateManager):
     """A state manager that stores states in memory."""
 
     # The mapping of client ids to states.
-    states: Dict[str, BaseState] = {}
+    states: dict[str, BaseState] = {}
 
     # The mutex ensures the dict of mutexes is updated exclusively
     _state_manager_lock = asyncio.Lock()
 
     # The dict of mutexes for each client
-    _states_locks: Dict[str, asyncio.Lock] = pydantic.PrivateAttr({})
+    _states_locks: dict[str, asyncio.Lock] = pydantic.PrivateAttr({})
 
     class Config:  # pyright: ignore [reportIncompatibleVariableOverride]
         """The Pydantic config."""
@@ -2970,13 +2981,13 @@ class StateManagerDisk(StateManager):
     """A state manager that stores states in memory."""
 
     # The mapping of client ids to states.
-    states: Dict[str, BaseState] = {}
+    states: dict[str, BaseState] = {}
 
     # The mutex ensures the dict of mutexes is updated exclusively
     _state_manager_lock = asyncio.Lock()
 
     # The dict of mutexes for each client
-    _states_locks: Dict[str, asyncio.Lock] = pydantic.PrivateAttr({})
+    _states_locks: dict[str, asyncio.Lock] = pydantic.PrivateAttr({})
 
     # The token expiration time (s).
     token_expiration: int = pydantic.Field(default_factory=_default_token_expiration)
@@ -3205,7 +3216,7 @@ class StateManagerRedis(StateManager):
         default_factory=_default_lock_warning_threshold
     )
 
-    # The keyspace subscription string when redis is waiting for lock to be released
+    # The keyspace subscription string when redis is waiting for lock to be released.
     _redis_notify_keyspace_events: str = (
         "K"  # Enable keyspace notifications (target a particular key)
         "g"  # For generic commands (DEL, EXPIRE, etc)
@@ -3213,14 +3224,20 @@ class StateManagerRedis(StateManager):
         "e"  # For evicted events (i.e. maxmemory exceeded)
     )
 
-    # These events indicate that a lock is no longer held
-    _redis_keyspace_lock_release_events: Set[bytes] = {
+    # These events indicate that a lock is no longer held.
+    _redis_keyspace_lock_release_events: set[bytes] = {
         b"del",
         b"expire",
         b"expired",
         b"evicted",
     }
 
+    # Whether keyspace notifications have been enabled.
+    _redis_notify_keyspace_events_enabled: bool = False
+
+    # The logical database number used by the redis client.
+    _redis_db: int = 0
+
     def _get_required_state_classes(
         self,
         target_state_cls: Type[BaseState],
@@ -3553,20 +3570,17 @@ class StateManagerRedis(StateManager):
                 return
             await self._get_pubsub_message(pubsub, timeout=remaining)
 
-    async def _wait_lock(self, lock_key: bytes, lock_id: bytes) -> None:
-        """Wait for a redis lock to be released via pubsub.
-
-        Coroutine will not return until the lock is obtained.
-
-        Args:
-            lock_key: The redis key for the lock.
-            lock_id: The ID of the lock.
+    async def _enable_keyspace_notifications(self):
+        """Enable keyspace notifications for the redis server.
 
         Raises:
             ResponseError: when the keyspace config cannot be set.
         """
-        lock_key_channel = f"__keyspace@0__:{lock_key.decode()}"
-        # Enable keyspace notifications for the lock key, so we know when it is available.
+        if self._redis_notify_keyspace_events_enabled:
+            return
+        # Find out which logical database index is being used.
+        self._redis_db = self.redis.get_connection_kwargs().get("db", self._redis_db)
+
         try:
             await self.redis.config_set(
                 "notify-keyspace-events",
@@ -3576,6 +3590,20 @@ class StateManagerRedis(StateManager):
             # Some redis servers only allow out-of-band configuration, so ignore errors here.
             if not environment.REFLEX_IGNORE_REDIS_CONFIG_ERROR.get():
                 raise
+        self._redis_notify_keyspace_events_enabled = True
+
+    async def _wait_lock(self, lock_key: bytes, lock_id: bytes) -> None:
+        """Wait for a redis lock to be released via pubsub.
+
+        Coroutine will not return until the lock is obtained.
+
+        Args:
+            lock_key: The redis key for the lock.
+            lock_id: The ID of the lock.
+        """
+        # Enable keyspace notifications for the lock key, so we know when it is available.
+        await self._enable_keyspace_notifications()
+        lock_key_channel = f"__keyspace@{self._redis_db}__:{lock_key.decode()}"
         async with self.redis.pubsub() as pubsub:
             await pubsub.psubscribe(lock_key_channel)
             # wait for the lock to be released
@@ -3687,7 +3715,7 @@ class MutableProxy(wrapt.ObjectProxy):
     )
 
     # Dynamically generated classes for tracking dataclass mutations.
-    __dataclass_proxies__: Dict[type, type] = {}
+    __dataclass_proxies__: dict[type, type] = {}
 
     def __new__(cls, wrapped: Any, *args, **kwargs) -> MutableProxy:
         """Create a proxy instance for a mutable object that tracks changes.

reflex/style.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal, Tuple, Type
+from typing import Any, Literal, Type
 
 from reflex import constants
 from reflex.components.core.breakpoints import Breakpoints, breakpoints_values
@@ -218,7 +218,7 @@ def convert(
     return out, var_data
 
 
-def format_style_key(key: str) -> Tuple[str, ...]:
+def format_style_key(key: str) -> tuple[str, ...]:
     """Convert style keys to camel case and convert shorthand
     styles names to their corresponding css names.
 
@@ -234,6 +234,9 @@ def format_style_key(key: str) -> Tuple[str, ...]:
     return STYLE_PROP_SHORTHAND_MAPPING.get(key, (key,))
 
 
+EMPTY_VAR_DATA = VarData()
+
+
 class Style(dict):
     """A style dictionary."""
 
@@ -248,7 +251,10 @@ class Style(dict):
             style_dict.update(kwargs)
         else:
             style_dict = kwargs
-        style_dict, self._var_data = convert(style_dict or {})
+        if style_dict:
+            style_dict, self._var_data = convert(style_dict)
+        else:
+            self._var_data = EMPTY_VAR_DATA
         super().__init__(style_dict)
 
     def update(self, style_dict: dict | None, **kwargs):