reflex 0.5.5a1__py3-none-any.whl → 0.5.6__py3-none-any.whl

reflex/app.py

@@ -7,12 +7,12 @@ import concurrent.futures
 import contextlib
 import copy
 import functools
-import inspect
 import io
 import multiprocessing
 import os
 import platform
 import sys
+from datetime import datetime
 from typing import (
     Any,
     AsyncIterator,
@@ -39,6 +39,7 @@ from starlette_admin.contrib.sqla.view import ModelView
 
 from reflex import constants
 from reflex.admin import AdminDash
+from reflex.app_mixins import AppMixin, LifespanMixin, MiddlewareMixin
 from reflex.base import Base
 from reflex.compiler import compiler
 from reflex.compiler import utils as compiler_utils
@@ -51,6 +52,7 @@ from reflex.components.component import (
     evaluate_style_namespaces,
 )
 from reflex.components.core.banner import connection_pulser, connection_toaster
+from reflex.components.core.breakpoints import set_breakpoints
 from reflex.components.core.client_side_routing import (
     Default404Page,
     wait_for_client_redirect,
@@ -59,7 +61,6 @@ from reflex.components.core.upload import Upload, get_upload_dir
 from reflex.components.radix import themes
 from reflex.config import get_config
 from reflex.event import Event, EventHandler, EventSpec
-from reflex.middleware import HydrateMiddleware, Middleware
 from reflex.model import Model
 from reflex.page import (
     DECORATED_PAGES,
@@ -78,8 +79,8 @@ from reflex.state import (
     _substate_key,
     code_uses_state_contexts,
 )
-from reflex.utils import console, exceptions, format, prerequisites, types
-from reflex.utils.exec import is_testing_env, should_skip_compile
+from reflex.utils import codespaces, console, exceptions, format, prerequisites, types
+from reflex.utils.exec import is_prod_mode, is_testing_env, should_skip_compile
 from reflex.utils.imports import ImportVar
 
 # Define custom types.
@@ -93,7 +94,11 @@ def default_overlay_component() -> Component:
     Returns:
         The default overlay_component, which is a connection_modal.
     """
-    return Fragment.create(connection_pulser(), connection_toaster())
+    return Fragment.create(
+        connection_pulser(),
+        connection_toaster(),
+        *codespaces.codespaces_auto_redirect(),
+    )
 
 
 class OverlayFragment(Fragment):
@@ -102,50 +107,7 @@ class OverlayFragment(Fragment):
     pass
 
 
-class LifespanMixin(Base):
-    """A Mixin that allow tasks to run during the whole app lifespan."""
-
-    # Lifespan tasks that are planned to run.
-    lifespan_tasks: Set[Union[asyncio.Task, Callable]] = set()
-
-    @contextlib.asynccontextmanager
-    async def _run_lifespan_tasks(self, app: FastAPI):
-        running_tasks = []
-        try:
-            async with contextlib.AsyncExitStack() as stack:
-                for task in self.lifespan_tasks:
-                    if isinstance(task, asyncio.Task):
-                        running_tasks.append(task)
-                    else:
-                        signature = inspect.signature(task)
-                        if "app" in signature.parameters:
-                            task = functools.partial(task, app=app)
-                        _t = task()
-                        if isinstance(_t, contextlib._AsyncGeneratorContextManager):
-                            await stack.enter_async_context(_t)
-                        elif isinstance(_t, Coroutine):
-                            running_tasks.append(asyncio.create_task(_t))
-                yield
-        finally:
-            cancel_kwargs = (
-                {"msg": "lifespan_cleanup"} if sys.version_info >= (3, 9) else {}
-            )
-            for task in running_tasks:
-                task.cancel(**cancel_kwargs)
-
-    def register_lifespan_task(self, task: Callable | asyncio.Task, **task_kwargs):
-        """Register a task to run during the lifespan of the app.
-
-        Args:
-            task: The task to register.
-            task_kwargs: The kwargs of the task.
-        """
-        if task_kwargs:
-            task = functools.partial(task, **task_kwargs)  # type: ignore
-        self.lifespan_tasks.add(task)  # type: ignore
-
-
-class App(LifespanMixin, Base):
+class App(MiddlewareMixin, LifespanMixin, Base):
     """The main Reflex app that encapsulates the backend and frontend.
 
     Every Reflex app needs an app defined in its main module.
@@ -204,9 +166,6 @@ class App(LifespanMixin, Base):
     # Class to manage many client states.
     _state_manager: Optional[StateManager] = None
 
-    # Middleware to add to the app. Users should use `add_middleware`. PRIVATE.
-    middleware: List[Middleware] = []
-
     # Mapping from a route to event handlers to trigger when the page loads. PRIVATE.
     load_events: Dict[str, List[Union[EventHandler, EventSpec]]] = {}
 
@@ -244,19 +203,31 @@ class App(LifespanMixin, Base):
                 "rx.BaseState cannot be subclassed multiple times. use rx.State instead"
             )
 
-        # Add middleware.
-        self.middleware.append(HydrateMiddleware())
+        if "breakpoints" in self.style:
+            set_breakpoints(self.style.pop("breakpoints"))
 
         # Set up the API.
         self.api = FastAPI(lifespan=self._run_lifespan_tasks)
         self._add_cors()
         self._add_default_endpoints()
 
+        for clz in App.__mro__:
+            if clz == App:
+                continue
+            if issubclass(clz, AppMixin):
+                clz._init_mixin(self)
+
         self._setup_state()
 
         # Set up the admin dash.
         self._setup_admin_dash()
 
+        if sys.platform == "win32" and not is_prod_mode():
+            # Hack to fix Windows hot reload issue.
+            from reflex.utils.compat import windows_hot_reload_lifespan_hack
+
+            self.register_lifespan_task(windows_hot_reload_lifespan_hack)
+
     def _enable_state(self) -> None:
         """Enable state for the app."""
         if not self.state:
@@ -341,6 +312,10 @@ class App(LifespanMixin, Base):
                 StaticFiles(directory=get_upload_dir()),
                 name="uploaded_files",
             )
+        if codespaces.is_running_in_codespaces():
+            self.api.get(str(constants.Endpoint.AUTH_CODESPACE))(
+                codespaces.auth_codespace
+            )
 
     def _add_cors(self):
         """Add CORS middleware to the app."""
@@ -366,77 +341,6 @@ class App(LifespanMixin, Base):
             raise ValueError("The state manager has not been initialized.")
         return self._state_manager
 
-    async def _preprocess(self, state: BaseState, event: Event) -> StateUpdate | None:
-        """Preprocess the event.
-
-        This is where middleware can modify the event before it is processed.
-        Each middleware is called in the order it was added to the app.
-
-        If a middleware returns an update, the event is not processed and the
-        update is returned.
-
-        Args:
-            state: The state to preprocess.
-            event: The event to preprocess.
-
-        Returns:
-            An optional state to return.
-        """
-        for middleware in self.middleware:
-            if asyncio.iscoroutinefunction(middleware.preprocess):
-                out = await middleware.preprocess(app=self, state=state, event=event)  # type: ignore
-            else:
-                out = middleware.preprocess(app=self, state=state, event=event)  # type: ignore
-            if out is not None:
-                return out  # type: ignore
-
-    async def _postprocess(
-        self, state: BaseState, event: Event, update: StateUpdate
-    ) -> StateUpdate:
-        """Postprocess the event.
-
-        This is where middleware can modify the delta after it is processed.
-        Each middleware is called in the order it was added to the app.
-
-        Args:
-            state: The state to postprocess.
-            event: The event to postprocess.
-            update: The current state update.
-
-        Returns:
-            The state update to return.
-        """
-        for middleware in self.middleware:
-            if asyncio.iscoroutinefunction(middleware.postprocess):
-                out = await middleware.postprocess(
-                    app=self,  # type: ignore
-                    state=state,
-                    event=event,
-                    update=update,
-                )
-            else:
-                out = middleware.postprocess(
-                    app=self,  # type: ignore
-                    state=state,
-                    event=event,
-                    update=update,
-                )
-            if out is not None:
-                return out  # type: ignore
-        return update
-
-    def add_middleware(self, middleware: Middleware, index: int | None = None):
-        """Add middleware to the app.
-
-        Args:
-            middleware: The middleware to add.
-            index: The index to add the middleware at.
-        """
-        if index is None:
-            self.middleware.append(middleware)
-        else:
-            self.middleware.insert(index, middleware)
-
     @staticmethod
     def _generate_component(component: Component | ComponentCallable) -> Component:
         """Generate a component from a callable.
@@ -797,6 +701,36 @@ class App(LifespanMixin, Base):
         for render, kwargs in DECORATED_PAGES[get_config().app_name]:
             self.add_page(render, **kwargs)
 
+    def _validate_var_dependencies(
+        self, state: Optional[Type[BaseState]] = None
+    ) -> None:
+        """Validate the dependencies of the vars in the app.
+
+        Args:
+            state: The state to validate the dependencies for.
+
+        Raises:
+            VarDependencyError: When a computed var has an invalid dependency.
+        """
+        if not self.state:
+            return
+
+        if not state:
+            state = self.state
+
+        for var in state.computed_vars.values():
+            if not var._cache:
+                continue
+            deps = var._deps(objclass=state)
+            for dep in deps:
+                if dep not in state.vars and dep not in state.backend_vars:
+                    raise exceptions.VarDependencyError(
+                        f"ComputedVar {var._var_name} on state {state.__name__} has an invalid dependency {dep}"
+                    )
+
+        for substate in state.class_subclasses:
+            self._validate_var_dependencies(substate)
+
     def _compile(self, export: bool = False):
         """Compile the app and output it to the pages folder.
 
@@ -808,6 +742,9 @@ class App(LifespanMixin, Base):
         """
         from reflex.utils.exceptions import ReflexRuntimeError
 
+        def get_compilation_time() -> str:
+            return str(datetime.now().time()).split(".")[0]
+
         # Render a default 404 page if the user didn't supply one
         if constants.Page404.SLUG not in self.pages:
             self.add_custom_404_page()
@@ -818,6 +755,7 @@ class App(LifespanMixin, Base):
         if not self._should_compile():
             return
 
+        self._validate_var_dependencies()
         self._setup_overlay_component()
 
         # Create a progress bar.
@@ -832,7 +770,7 @@ class App(LifespanMixin, Base):
         fixed_pages_within_executor = 5
         progress.start()
         task = progress.add_task(
-            "Compiling:",
+            f"[{get_compilation_time()}] Compiling:",
             total=len(self.pages)
             + fixed_pages_within_executor
             + adhoc_steps_without_executor,

reflex/app_mixins/__init__.py

@@ -0,0 +1,5 @@
+"""Reflex AppMixins package."""
+
+from .lifespan import LifespanMixin
+from .middleware import MiddlewareMixin
+from .mixin import AppMixin

reflex/app_mixins/lifespan.py

@@ -0,0 +1,57 @@
+"""Mixin that allow tasks to run during the whole app lifespan."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import functools
+import inspect
+import sys
+from typing import Callable, Coroutine, Set, Union
+
+from fastapi import FastAPI
+
+from .mixin import AppMixin
+
+
+class LifespanMixin(AppMixin):
+    """A Mixin that allow tasks to run during the whole app lifespan."""
+
+    # Lifespan tasks that are planned to run.
+    lifespan_tasks: Set[Union[asyncio.Task, Callable]] = set()
+
+    @contextlib.asynccontextmanager
+    async def _run_lifespan_tasks(self, app: FastAPI):
+        running_tasks = []
+        try:
+            async with contextlib.AsyncExitStack() as stack:
+                for task in self.lifespan_tasks:
+                    if isinstance(task, asyncio.Task):
+                        running_tasks.append(task)
+                    else:
+                        signature = inspect.signature(task)
+                        if "app" in signature.parameters:
+                            task = functools.partial(task, app=app)
+                        _t = task()
+                        if isinstance(_t, contextlib._AsyncGeneratorContextManager):
+                            await stack.enter_async_context(_t)
+                        elif isinstance(_t, Coroutine):
+                            running_tasks.append(asyncio.create_task(_t))
+                yield
+        finally:
+            cancel_kwargs = (
+                {"msg": "lifespan_cleanup"} if sys.version_info >= (3, 9) else {}
+            )
+            for task in running_tasks:
+                task.cancel(**cancel_kwargs)
+
+    def register_lifespan_task(self, task: Callable | asyncio.Task, **task_kwargs):
+        """Register a task to run during the lifespan of the app.
+
+        Args:
+            task: The task to register.
+            task_kwargs: The kwargs of the task.
+        """
+        if task_kwargs:
+            task = functools.partial(task, **task_kwargs)  # type: ignore
+        self.lifespan_tasks.add(task)  # type: ignore

reflex/app_mixins/middleware.py

@@ -0,0 +1,93 @@
+"""Middleware Mixin that allow to add middleware to the app."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import List
+
+from reflex.event import Event
+from reflex.middleware import HydrateMiddleware, Middleware
+from reflex.state import BaseState, StateUpdate
+
+from .mixin import AppMixin
+
+
+class MiddlewareMixin(AppMixin):
+    """Middleware Mixin that allow to add middleware to the app."""
+
+    # Middleware to add to the app. Users should use `add_middleware`. PRIVATE.
+    middleware: List[Middleware] = []
+
+    def _init_mixin(self):
+        self.middleware.append(HydrateMiddleware())
+
+    def add_middleware(self, middleware: Middleware, index: int | None = None):
+        """Add middleware to the app.
+
+        Args:
+            middleware: The middleware to add.
+            index: The index to add the middleware at.
+        """
+        if index is None:
+            self.middleware.append(middleware)
+        else:
+            self.middleware.insert(index, middleware)
+
+    async def _preprocess(self, state: BaseState, event: Event) -> StateUpdate | None:
+        """Preprocess the event.
+
+        This is where middleware can modify the event before it is processed.
+        Each middleware is called in the order it was added to the app.
+
+        If a middleware returns an update, the event is not processed and the
+        update is returned.
+
+        Args:
+            state: The state to preprocess.
+            event: The event to preprocess.
+
+        Returns:
+            An optional state to return.
+        """
+        for middleware in self.middleware:
+            if asyncio.iscoroutinefunction(middleware.preprocess):
+                out = await middleware.preprocess(app=self, state=state, event=event)  # type: ignore
+            else:
+                out = middleware.preprocess(app=self, state=state, event=event)  # type: ignore
+            if out is not None:
+                return out  # type: ignore
+
+    async def _postprocess(
+        self, state: BaseState, event: Event, update: StateUpdate
+    ) -> StateUpdate:
+        """Postprocess the event.
+
+        This is where middleware can modify the delta after it is processed.
+        Each middleware is called in the order it was added to the app.
+
+        Args:
+            state: The state to postprocess.
+            event: The event to postprocess.
+            update: The current state update.
+
+        Returns:
+            The state update to return.
+        """
+        for middleware in self.middleware:
+            if asyncio.iscoroutinefunction(middleware.postprocess):
+                out = await middleware.postprocess(
+                    app=self,  # type: ignore
+                    state=state,
+                    event=event,
+                    update=update,
+                )
+            else:
+                out = middleware.postprocess(
+                    app=self,  # type: ignore
+                    state=state,
+                    event=event,
+                    update=update,
+                )
+            if out is not None:
+                return out  # type: ignore
+        return update

reflex/app_mixins/mixin.py

@@ -0,0 +1,14 @@
+"""Default mixin for all app mixins."""
+
+from reflex.base import Base
+
+
+class AppMixin(Base):
+    """Define the base class for all app mixins."""
+
+    def _init_mixin(self):
+        """Initialize the mixin.
+
+        Any App mixin can override this method to perform any initialization.
+        """
+        ...

reflex/compiler/compiler.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, Iterable, Optional, Type, Union
 
@@ -79,20 +80,24 @@ def _compile_contexts(state: Optional[Type[BaseState]], theme: Component | None)
         The compiled context file.
     """
     appearance = getattr(theme, "appearance", None)
-    if appearance is None:
+    if appearance is None or Var.create_safe(appearance)._var_name == "inherit":
         appearance = SYSTEM_COLOR_MODE
+
+    last_compiled_time = str(datetime.now())
     return (
         templates.CONTEXT.render(
             initial_state=utils.compile_state(state),
             state_name=state.get_name(),
             client_storage=utils.compile_client_storage(state),
             is_dev_mode=not is_prod_mode(),
+            last_compiled_time=last_compiled_time,
             default_color_mode=appearance,
         )
         if state
         else templates.CONTEXT.render(
             is_dev_mode=not is_prod_mode(),
             default_color_mode=appearance,
+            last_compiled_time=last_compiled_time,
         )
     )
 

reflex/components/__init__.pyi

@@ -18,9 +18,7 @@ from . import react_player as react_player
 from . import recharts as recharts
 from . import sonner as sonner
 from . import suneditor as suneditor
-
 from .component import Component as Component
 from .component import NoSSRComponent as NoSSRComponent
 from .next import NextLink as NextLink
 from .next import next_link as next_link
-from reflex.utils import lazy_loader

reflex/components/base/__init__.pyi

@@ -5,7 +5,6 @@
 
 from . import app_wrap as app_wrap
 from . import bare as bare
-
 from .body import Body as Body
 from .document import DocumentHead as DocumentHead
 from .document import Html as Html
@@ -13,8 +12,8 @@ from .document import Main as Main
 from .document import NextScript as NextScript
 from .fragment import Fragment as Fragment
 from .fragment import fragment as fragment
-from .head import head as head
 from .head import Head as Head
+from .head import head as head
 from .link import RawLink as RawLink
 from .link import ScriptTag as ScriptTag
 from .meta import Description as Description
@@ -23,4 +22,3 @@ from .meta import Meta as Meta
 from .meta import Title as Title
 from .script import Script as Script
 from .script import script as script
-from reflex.utils import lazy_loader

reflex/components/base/app_wrap.pyi

@@ -1,15 +1,14 @@
 """Stub file for reflex/components/base/app_wrap.py"""
+
 # ------------------- DO NOT EDIT ----------------------
 # This file was generated by `reflex/utils/pyi_generator.py`!
 # ------------------------------------------------------
+from typing import Any, Callable, Dict, Optional, Union, overload
 
-from typing import Any, Dict, Literal, Optional, Union, overload
-from reflex.vars import Var, BaseVar, ComputedVar
-from reflex.event import EventChain, EventHandler, EventSpec
-from reflex.style import Style
 from reflex.components.base.fragment import Fragment
-from reflex.components.component import Component
-from reflex.vars import Var
+from reflex.event import EventHandler, EventSpec
+from reflex.style import Style
+from reflex.vars import BaseVar, Var
 
 class AppWrap(Fragment):
     @overload
@@ -24,51 +23,51 @@ class AppWrap(Fragment):
         autofocus: Optional[bool] = None,
         custom_attrs: Optional[Dict[str, Union[Var, str]]] = None,
         on_blur: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_click: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_context_menu: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_double_click: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_focus: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mount: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_down: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_enter: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_leave: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_move: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_out: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_over: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_mouse_up: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_scroll: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
         on_unmount: Optional[
-            Union[EventHandler, EventSpec, list, function, BaseVar]
+            Union[EventHandler, EventSpec, list, Callable, BaseVar]
         ] = None,
-        **props
+        **props,
     ) -> "AppWrap":
         """Create a new AppWrap component.