reflex 0.8.2a1__py3-none-any.whl → 0.8.3a2__py3-none-any.whl

reflex/components/recharts/recharts.py

@@ -8,7 +8,7 @@ from reflex.components.component import Component, MemoizationLeaf, NoSSRCompone
 class Recharts(Component):
     """A component that wraps a recharts lib."""
 
-    library = "recharts@3.0.2"
+    library = "recharts@3.1.0"
 
     def _get_style(self) -> dict:
         return {"wrapperStyle": self.style}
@@ -17,7 +17,7 @@ class Recharts(Component):
 class RechartsCharts(NoSSRComponent, MemoizationLeaf):
     """A component that wraps a recharts lib."""
 
-    library = "recharts@3.0.2"
+    library = "recharts@3.1.0"
 
 
 LiteralAnimationEasing = Literal["ease", "ease-in", "ease-out", "ease-in-out", "linear"]

reflex/components/sonner/toast.py

@@ -171,7 +171,7 @@ class ToastProps(NoExtrasAllowedProps):
 class Toaster(Component):
     """A Toaster Component for displaying toast notifications."""
 
-    library: str | None = "sonner@2.0.5"
+    library: str | None = "sonner@2.0.6"
 
     tag = "Toaster"
 

reflex/config.py

@@ -294,14 +294,14 @@ class Config(BaseConfig):
         if env_loglevel or self.loglevel != LogLevel.DEFAULT:
             console.set_log_level(env_loglevel or self.loglevel)
 
-        # Add builtin plugins if not disabled.
-        self._add_builtin_plugins()
-
         # Update the config from environment variables.
         env_kwargs = self.update_from_env()
         for key, env_value in env_kwargs.items():
             setattr(self, key, env_value)
 
+        # Add builtin plugins if not disabled.
+        self._add_builtin_plugins()
+
         #   Update default URLs if ports were set
         kwargs.update(env_kwargs)
         self._non_default_attributes = set(kwargs.keys())

reflex/constants/installer.py

@@ -143,10 +143,11 @@ class PackageJson(SimpleNamespace):
         "postcss-import": "16.1.1",
         "@react-router/dev": _react_router_version,
         "@react-router/fs-routes": _react_router_version,
-        "rolldown-vite": "7.0.8",
+        "rolldown-vite": "7.0.9",
     }
     OVERRIDES = {
         # This should always match the `react` version in DEPENDENCIES for recharts compatibility.
         "react-is": _react_version,
         "cookie": "1.0.2",
+        "rollup": "4.44.2",
     }

reflex/environment.py

@@ -650,6 +650,9 @@ class EnvironmentVariables:
     # Enable full logging of debug messages to reflex user directory.
     REFLEX_ENABLE_FULL_LOGGING: EnvVar[bool] = env_var(False)
 
+    # The path to the reflex errors log file. If not set, no separate error log will be used.
+    REFLEX_ERROR_LOG_FILE: EnvVar[Path | None] = env_var(None)
+
 
 environment = EnvironmentVariables()
 

reflex/event.py

@@ -109,7 +109,7 @@ class EventActionsMixin:
         """
         return dataclasses.replace(
             self,
-            event_actions={"stopPropagation": True, **self.event_actions},
+            event_actions={**self.event_actions, "stopPropagation": True},
         )
 
     @property
@@ -121,7 +121,7 @@ class EventActionsMixin:
         """
         return dataclasses.replace(
             self,
-            event_actions={"preventDefault": True, **self.event_actions},
+            event_actions={**self.event_actions, "preventDefault": True},
         )
 
     def throttle(self, limit_ms: int) -> Self:
@@ -135,7 +135,7 @@ class EventActionsMixin:
         """
         return dataclasses.replace(
             self,
-            event_actions={"throttle": limit_ms, **self.event_actions},
+            event_actions={**self.event_actions, "throttle": limit_ms},
         )
 
     def debounce(self, delay_ms: int) -> Self:
@@ -149,7 +149,7 @@ class EventActionsMixin:
         """
         return dataclasses.replace(
             self,
-            event_actions={"debounce": delay_ms, **self.event_actions},
+            event_actions={**self.event_actions, "debounce": delay_ms},
         )
 
     @property
@@ -161,7 +161,7 @@ class EventActionsMixin:
         """
         return dataclasses.replace(
             self,
-            event_actions={"temporal": True, **self.event_actions},
+            event_actions={**self.event_actions, "temporal": True},
         )
 
 
@@ -1269,7 +1269,7 @@ def call_script(
     Returns:
         EventSpec: An event that will execute the client side javascript.
     """
-    callback_kwargs = {}
+    callback_kwargs = {"callback": None}
     if callback is not None:
         callback_kwargs = {
             "callback": str(
@@ -2211,7 +2211,15 @@ class EventNamespace:
 
     @overload
     def __new__(
-        cls, func: None = None, *, background: bool | None = None
+        cls,
+        func: None = None,
+        *,
+        background: bool | None = None,
+        stop_propagation: bool | None = None,
+        prevent_default: bool | None = None,
+        throttle: int | None = None,
+        debounce: int | None = None,
+        temporal: bool | None = None,
     ) -> Callable[
         [Callable[[BASE_STATE, Unpack[P]], Any]], EventCallback[Unpack[P]]  # pyright: ignore [reportInvalidTypeVarUse]
     ]: ...
@@ -2222,6 +2230,11 @@ class EventNamespace:
         func: Callable[[BASE_STATE, Unpack[P]], Any],
         *,
         background: bool | None = None,
+        stop_propagation: bool | None = None,
+        prevent_default: bool | None = None,
+        throttle: int | None = None,
+        debounce: int | None = None,
+        temporal: bool | None = None,
     ) -> EventCallback[Unpack[P]]: ...
 
     def __new__(
@@ -2229,6 +2242,11 @@ class EventNamespace:
         func: Callable[[BASE_STATE, Unpack[P]], Any] | None = None,
         *,
         background: bool | None = None,
+        stop_propagation: bool | None = None,
+        prevent_default: bool | None = None,
+        throttle: int | None = None,
+        debounce: int | None = None,
+        temporal: bool | None = None,
     ) -> (
         EventCallback[Unpack[P]]
         | Callable[[Callable[[BASE_STATE, Unpack[P]], Any]], EventCallback[Unpack[P]]]
@@ -2238,6 +2256,11 @@ class EventNamespace:
         Args:
             func: The function to wrap.
             background: Whether the event should be run in the background. Defaults to False.
+            stop_propagation: Whether to stop the event from bubbling up the DOM tree.
+            prevent_default: Whether to prevent the default behavior of the event.
+            throttle: Throttle the event handler to limit calls (in milliseconds).
+            debounce: Debounce the event handler to delay calls (in milliseconds).
+            temporal: Whether the event should be dropped when the backend is down.
 
         Raises:
             TypeError: If background is True and the function is not a coroutine or async generator. # noqa: DAR402
@@ -2246,6 +2269,30 @@ class EventNamespace:
             The wrapped function.
         """
 
+        def _build_event_actions():
+            """Build event_actions dict from decorator parameters.
+
+            Returns:
+                Dict of event actions to apply, or empty dict if none specified.
+            """
+            if not any(
+                [stop_propagation, prevent_default, throttle, debounce, temporal]
+            ):
+                return {}
+
+            event_actions = {}
+            if stop_propagation is not None:
+                event_actions["stopPropagation"] = stop_propagation
+            if prevent_default is not None:
+                event_actions["preventDefault"] = prevent_default
+            if throttle is not None:
+                event_actions["throttle"] = throttle
+            if debounce is not None:
+                event_actions["debounce"] = debounce
+            if temporal is not None:
+                event_actions["temporal"] = temporal
+            return event_actions
+
         def wrapper(
             func: Callable[[BASE_STATE, Unpack[P]], T],
         ) -> EventCallback[Unpack[P]]:
@@ -2281,8 +2328,22 @@ class EventNamespace:
                     object.__setattr__(func, "__name__", name)
                     object.__setattr__(func, "__qualname__", name)
                     state_cls._add_event_handler(name, func)
-                    return getattr(state_cls, name)
+                    event_callback = getattr(state_cls, name)
+
+                    # Apply decorator event actions
+                    event_actions = _build_event_actions()
+                    if event_actions:
+                        # Create new EventCallback with updated event_actions
+                        event_callback = dataclasses.replace(
+                            event_callback, event_actions=event_actions
+                        )
+
+                    return event_callback
 
+            # Store decorator event actions on the function for later processing
+            event_actions = _build_event_actions()
+            if event_actions:
+                func._rx_event_actions = event_actions  # pyright: ignore [reportFunctionMemberAccess]
             return func  # pyright: ignore [reportReturnType]
 
         if func is not None:

reflex/model.py

@@ -19,6 +19,7 @@ import sqlalchemy.exc
 import sqlalchemy.ext.asyncio
 import sqlalchemy.orm
 from alembic.runtime.migration import MigrationContext
+from alembic.script.base import Script
 
 from reflex.base import Base
 from reflex.config import get_config
@@ -34,6 +35,41 @@ _AsyncSessionLocal: dict[str | None, sqlalchemy.ext.asyncio.async_sessionmaker]
 from sqlmodel.ext.asyncio.session import AsyncSession  # noqa: E402
 
 
+def format_revision(
+    rev: Script,
+    current_rev: str | None,
+    current_reached_ref: list[bool],
+) -> str:
+    """Format a single revision for display.
+
+    Args:
+        rev: The alembic script object
+        current_rev: The currently applied revision ID
+        current_reached_ref: Mutable reference to track if we've reached current revision
+
+    Returns:
+        Formatted string for display
+    """
+    current = rev.revision
+    message = rev.doc
+
+    # Determine if this migration is applied
+    if current_rev is None:
+        is_applied = False
+    elif current == current_rev:
+        is_applied = True
+        current_reached_ref[0] = True
+    else:
+        is_applied = not current_reached_ref[0]
+
+    # Show checkmark or X with colors
+    status_icon = "[green]✓[/green]" if is_applied else "[red]✗[/red]"
+    head_marker = " (head)" if rev.is_head else ""
+
+    # Format output with message
+    return f"  [{status_icon}] {current}{head_marker}, {message}"
+
+
 def _safe_db_url_for_logging(url: str) -> str:
     """Remove username and password from the database URL for logging.
 
@@ -361,6 +397,25 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
             directory=str(environment.ALEMBIC_CONFIG.get().parent / "alembic"),
         )
 
+    @classmethod
+    def get_migration_history(cls):
+        """Get migration history with current database state.
+
+        Returns:
+            tuple: (current_revision, revisions_list) where revisions_list is in chronological order
+        """
+        # Get current revision from database
+        with cls.get_db_engine().connect() as connection:
+            context = MigrationContext.configure(connection)
+            current_rev = context.get_current_revision()
+
+        # Get all revisions from base to head
+        _, script_dir = cls._alembic_config()
+        revisions = list(script_dir.walk_revisions())
+        revisions.reverse()  # Reverse to get chronological order (base first)
+
+        return current_rev, revisions
+
     @classmethod
     def alembic_autogenerate(
         cls,

reflex/reflex.py

@@ -540,6 +540,39 @@ def migrate():
     prerequisites.check_schema_up_to_date()
 
 
+@db_cli.command()
+def status():
+    """Check the status of the database schema."""
+    from reflex.model import Model, format_revision
+    from reflex.utils import prerequisites
+
+    prerequisites.get_app()
+    if not prerequisites.check_db_initialized():
+        console.info(
+            "Database is not initialized. Run [bold]reflex db init[/bold] to initialize."
+        )
+        return
+
+    # Run alembic check command and display output
+    import reflex.config
+
+    config = reflex.config.get_config()
+    console.print(f"[bold]\\[{config.db_url}][/bold]")
+
+    # Get migration history using Model method
+    current_rev, revisions = Model.get_migration_history()
+    if current_rev is None and not revisions:
+        return
+
+    current_reached_ref = [current_rev is None]
+
+    # Show migration history in chronological order
+    console.print("<base>")
+    for rev in revisions:
+        # Format and print the revision
+        console.print(format_revision(rev, current_rev, current_reached_ref))
+
+
 @db_cli.command()
 @click.option(
     "--message",

reflex/state.py

@@ -1100,7 +1100,12 @@ class BaseState(EvenMoreBasicBaseState):
         Returns:
             The event handler.
         """
-        return EventHandler(fn=fn, state_full_name=cls.get_full_name())
+        # Check if function has stored event_actions from decorator
+        event_actions = getattr(fn, "_rx_event_actions", {})
+
+        return EventHandler(
+            fn=fn, state_full_name=cls.get_full_name(), event_actions=event_actions
+        )
 
     @classmethod
     def _create_setvar(cls):
@@ -2412,19 +2417,19 @@ class FrontendEventExceptionState(State):
     """Substate for handling frontend exceptions."""
 
     @event
-    def handle_frontend_exception(self, stack: str, component_stack: str) -> None:
+    def handle_frontend_exception(self, info: str, component_stack: str) -> None:
         """Handle frontend exceptions.
 
         If a frontend exception handler is provided, it will be called.
         Otherwise, the default frontend exception handler will be called.
 
         Args:
-            stack: The stack trace of the exception.
+            info: The exception information.
             component_stack: The stack trace of the component where the exception occurred.
 
         """
         prerequisites.get_and_validate_app().app.frontend_exception_handler(
-            Exception(stack)
+            Exception(info)
         )