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

reflex/app.py

@@ -63,9 +63,8 @@ from reflex.page import (
     DECORATED_PAGES,
 )
 from reflex.route import (
-    catchall_in_route,
-    catchall_prefix,
     get_route_args,
+    replace_brackets_with_keywords,
     verify_route_validity,
 )
 from reflex.state import (
@@ -102,69 +101,83 @@ class OverlayFragment(Fragment):
 
 
 class App(Base):
-    """A Reflex application."""
+    """The main Reflex app that encapsulates the backend and frontend.
 
-    # A map from a page route to the component to render.
-    pages: Dict[str, Component] = {}
+    Every Reflex app needs an app defined in its main module.
+
+    ```python
+    # app.py
+    import reflex as rx
+
+    # Define state and pages
+    ...
+
+    app = rx.App(
+        # Set global level style.
+        style={...},
+        # Set the top level theme.
+        theme=rx.theme(accent_color="blue"),
+    )
+    ```
+    """
+
+    # The global [theme](https://reflex.dev/docs/styling/theming/#theme) for the entire app.
+    theme: Optional[Component] = themes.theme(accent_color="blue")
+
+    # The [global style](https://reflex.dev/docs/styling/overview/#global-styles}) for the app.
+    style: ComponentStyle = {}
 
-    # A list of URLs to stylesheets to include in the app.
+    # A list of URLs to [stylesheets](https://reflex.dev/docs/styling/custom-stylesheets/) to include in the app.
     stylesheets: List[str] = []
 
-    # The backend API object.
-    api: FastAPI = None  # type: ignore
+    # A component that is present on every page (defaults to the Connection Error banner).
+    overlay_component: Optional[
+        Union[Component, ComponentCallable]
+    ] = default_overlay_component
 
-    # The Socket.IO AsyncServer.
+    # Components to add to the head of every page.
+    head_components: List[Component] = []
+
+    # The Socket.IO AsyncServer instance.
     sio: Optional[AsyncServer] = None
 
-    # The socket app.
-    socket_app: Optional[ASGIApp] = None
+    # The language to add to the html root tag of every page.
+    html_lang: Optional[str] = None
+
+    # Attributes to add to the html root tag of every page.
+    html_custom_attrs: Optional[Dict[str, str]] = None
+
+    # A map from a page route to the component to render. Users should use `add_page`. PRIVATE.
+    pages: Dict[str, Component] = {}
+
+    # The backend API object. PRIVATE.
+    api: FastAPI = None  # type: ignore
 
-    # The state class to use for the app.
+    # The state class to use for the app. PRIVATE.
     state: Optional[Type[BaseState]] = None
 
     # Class to manage many client states.
     _state_manager: Optional[StateManager] = None
 
-    # The styling to apply to each component.
-    style: ComponentStyle = {}
-
-    # Middleware to add to the app.
+    # Middleware to add to the app. Users should use `add_middleware`. PRIVATE.
     middleware: List[Middleware] = []
 
-    # List of event handlers to trigger when a page loads.
+    # Mapping from a route to event handlers to trigger when the page loads. PRIVATE.
     load_events: Dict[str, List[Union[EventHandler, EventSpec]]] = {}
 
-    # Admin dashboard
+    # Admin dashboard to view and manage the database. PRIVATE.
     admin_dash: Optional[AdminDash] = None
 
-    # The async server name space
+    # The async server name space. PRIVATE.
     event_namespace: Optional[EventNamespace] = None
 
-    # Components to add to the head of every page.
-    head_components: List[Component] = []
-
-    # The language to add to the html root tag of every page.
-    html_lang: Optional[str] = None
-
-    # Attributes to add to the html root tag of every page.
-    html_custom_attrs: Optional[Dict[str, str]] = None
-
-    # A component that is present on every page.
-    overlay_component: Optional[
-        Union[Component, ComponentCallable]
-    ] = default_overlay_component
-
-    # Background tasks that are currently running
+    # Background tasks that are currently running. PRIVATE.
     background_tasks: Set[asyncio.Task] = set()
 
-    # The radix theme for the entire app
-    theme: Optional[Component] = themes.theme(accent_color="blue")
-
-    def __init__(self, *args, **kwargs):
+    def __init__(self, **kwargs):
         """Initialize the app.
 
         Args:
-            *args: Args to initialize the app with.
             **kwargs: Kwargs to initialize the app with.
 
         Raises:
@@ -176,45 +189,41 @@ class App(Base):
             raise ValueError(
                 "`connect_error_component` is deprecated, use `overlay_component` instead"
             )
-        super().__init__(*args, **kwargs)
+        super().__init__(**kwargs)
         base_state_subclasses = BaseState.__subclasses__()
 
         # Special case to allow test cases have multiple subclasses of rx.BaseState.
-        if not is_testing_env():
+        if not is_testing_env() and len(base_state_subclasses) > 1:
             # Only one Base State class is allowed.
-            if len(base_state_subclasses) > 1:
-                raise ValueError(
-                    "rx.BaseState cannot be subclassed multiple times. use rx.State instead"
-                )
+            raise ValueError(
+                "rx.BaseState cannot be subclassed multiple times. use rx.State instead"
+            )
 
-            if "state" in kwargs:
-                console.deprecate(
-                    feature_name="`state` argument for App()",
-                    reason="due to all `rx.State` subclasses being inferred.",
-                    deprecation_version="0.3.5",
-                    removal_version="0.5.0",
-                )
         # Add middleware.
         self.middleware.append(HydrateMiddleware())
 
         # Set up the API.
         self.api = FastAPI()
-        self.add_cors()
-        self.add_default_endpoints()
+        self._add_cors()
+        self._add_default_endpoints()
 
-        self.setup_state()
+        self._setup_state()
 
         # Set up the admin dash.
-        self.setup_admin_dash()
+        self._setup_admin_dash()
 
-    def enable_state(self) -> None:
+    def _enable_state(self) -> None:
         """Enable state for the app."""
         if not self.state:
             self.state = State
-            self.setup_state()
+            self._setup_state()
+
+    def _setup_state(self) -> None:
+        """Set up the state for the app.
 
-    def setup_state(self) -> None:
-        """Set up the state for the app."""
+        Raises:
+            RuntimeError: If the socket server is invalid.
+        """
         if not self.state:
             return
 
@@ -224,21 +233,26 @@ class App(Base):
         self._state_manager = StateManager.create(state=self.state)
 
         # Set up the Socket.IO AsyncServer.
-        self.sio = AsyncServer(
-            async_mode="asgi",
-            cors_allowed_origins=(
-                "*"
-                if config.cors_allowed_origins == ["*"]
-                else config.cors_allowed_origins
-            ),
-            cors_credentials=True,
-            max_http_buffer_size=constants.POLLING_MAX_HTTP_BUFFER_SIZE,
-            ping_interval=constants.Ping.INTERVAL,
-            ping_timeout=constants.Ping.TIMEOUT,
-        )
+        if not self.sio:
+            self.sio = AsyncServer(
+                async_mode="asgi",
+                cors_allowed_origins=(
+                    "*"
+                    if config.cors_allowed_origins == ["*"]
+                    else config.cors_allowed_origins
+                ),
+                cors_credentials=True,
+                max_http_buffer_size=constants.POLLING_MAX_HTTP_BUFFER_SIZE,
+                ping_interval=constants.Ping.INTERVAL,
+                ping_timeout=constants.Ping.TIMEOUT,
+            )
+        elif getattr(self.sio, "async_mode", "") != "asgi":
+            raise RuntimeError(
+                f"Custom `sio` must use `async_mode='asgi'`, not '{self.sio.async_mode}'."
+            )
 
         # Create the socket app. Note event endpoint constant replaces the default 'socket.io' path.
-        self.socket_app = ASGIApp(self.sio, socketio_path="")
+        socket_app = ASGIApp(self.sio, socketio_path="")
         namespace = config.get_event_namespace()
 
         # Create the event namespace and attach the main app. Not related to any paths.
@@ -247,7 +261,7 @@ class App(Base):
         # Register the event namespace with the socket.
         self.sio.register_namespace(self.event_namespace)
         # Mount the socket app with the API.
-        self.api.mount(str(constants.Endpoint.EVENT), self.socket_app)
+        self.api.mount(str(constants.Endpoint.EVENT), socket_app)
 
     def __repr__(self) -> str:
         """Get the string representation of the app.
@@ -265,12 +279,12 @@ class App(Base):
         """
         return self.api
 
-    def add_default_endpoints(self):
+    def _add_default_endpoints(self):
         """Add default api endpoints (ping)."""
         # To test the server.
         self.api.get(str(constants.Endpoint.PING))(ping)
 
-    def add_optional_endpoints(self):
+    def _add_optional_endpoints(self):
         """Add optional api endpoints (_upload)."""
         # To upload files.
         if Upload.is_used:
@@ -283,7 +297,7 @@ class App(Base):
                 name="uploaded_files",
             )
 
-    def add_cors(self):
+    def _add_cors(self):
         """Add CORS middleware to the app."""
         self.api.add_middleware(
             cors.CORSMiddleware,
@@ -307,7 +321,7 @@ class App(Base):
             raise ValueError("The state manager has not been initialized.")
         return self._state_manager
 
-    async def preprocess(self, state: BaseState, event: Event) -> StateUpdate | None:
+    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.
@@ -331,7 +345,7 @@ class App(Base):
             if out is not None:
                 return out  # type: ignore
 
-    async def postprocess(
+    async def _postprocess(
         self, state: BaseState, event: Event, update: StateUpdate
     ) -> StateUpdate:
         """Postprocess the event.
@@ -350,11 +364,17 @@ class App(Base):
         for middleware in self.middleware:
             if asyncio.iscoroutinefunction(middleware.postprocess):
                 out = await middleware.postprocess(
-                    app=self, state=state, event=event, update=update  # type: ignore
+                    app=self,  # type: ignore
+                    state=state,
+                    event=event,
+                    update=update,
                 )
             else:
                 out = middleware.postprocess(
-                    app=self, state=state, event=event, update=update  # type: ignore
+                    app=self,  # type: ignore
+                    state=state,
+                    event=event,
+                    update=update,
                 )
             if out is not None:
                 return out  # type: ignore
@@ -411,7 +431,6 @@ class App(Base):
             EventHandler | EventSpec | list[EventHandler | EventSpec] | None
         ) = None,
         meta: list[dict[str, str]] = constants.DefaultPage.META_LIST,
-        script_tags: list[Component] | None = None,
     ):
         """Add a page to the app.
 
@@ -426,7 +445,9 @@ class App(Base):
             image: The image to display on the page.
             on_load: The event handler(s) that will be called each time the page load.
             meta: The metadata of the page.
-            script_tags: List of script tags to be added to component
+
+        Raises:
+            ValueError: When the specified route name already exists.
         """
         # If the route is not set, get it from the callable.
         if route is None:
@@ -441,6 +462,23 @@ class App(Base):
         # Check if the route given is valid
         verify_route_validity(route)
 
+        if route in self.pages and os.getenv(constants.RELOAD_CONFIG):
+            # when the app is reloaded(typically for app harness tests), we should maintain
+            # the latest render function of a route.This applies typically to decorated pages
+            # since they are only added when app._compile is called.
+            self.pages.pop(route)
+
+        if route in self.pages:
+            route_name = (
+                f"`{route}` or `/`"
+                if route == constants.PageNames.INDEX_ROUTE
+                else f"`{route}`"
+            )
+            raise ValueError(
+                f"Duplicate page route {route_name} already exists. Make sure you do not have two"
+                f" pages with the same route"
+            )
+
         # Setup dynamic args for the route.
         # this state assignment is only required for tests using the deprecated state kwarg for App
         state = self.state if self.state else State
@@ -456,14 +494,14 @@ class App(Base):
         # Ensure state is enabled if this page uses state.
         if self.state is None:
             if on_load or component._has_event_triggers():
-                self.enable_state()
+                self._enable_state()
             else:
                 for var in component._get_vars(include_children=True):
                     if not var._var_data:
                         continue
                     if not var._var_data.state:
                         continue
-                    self.enable_state()
+                    self._enable_state()
                     break
 
         component = OverlayFragment.create(component)
@@ -487,16 +525,6 @@ class App(Base):
             **meta_args,
         )
 
-        # Add script tags if given
-        if script_tags:
-            console.deprecate(
-                feature_name="Passing script tags to add_page",
-                reason="Add script components as children to the page component instead",
-                deprecation_version="0.2.9",
-                removal_version="0.5.0",
-            )
-            component.children.extend(script_tags)
-
         # Add the page.
         self._check_routes_conflict(route)
         self.pages[route] = component
@@ -532,27 +560,31 @@ class App(Base):
         Args:
             new_route: the route being newly added.
         """
-        newroute_catchall = catchall_in_route(new_route)
-        if not newroute_catchall:
+        if "[" not in new_route:
             return
 
+        segments = (
+            constants.RouteRegex.SINGLE_SEGMENT,
+            constants.RouteRegex.DOUBLE_SEGMENT,
+            constants.RouteRegex.SINGLE_CATCHALL_SEGMENT,
+            constants.RouteRegex.DOUBLE_CATCHALL_SEGMENT,
+        )
         for route in self.pages:
-            route = "" if route == "index" else route
-
-            if new_route.startswith(f"{route}/[[..."):
-                raise ValueError(
-                    f"You cannot define a route with the same specificity as a optional catch-all route ('{route}' and '{new_route}')"
-                )
-
-            route_catchall = catchall_in_route(route)
-            if (
-                route_catchall
-                and newroute_catchall
-                and catchall_prefix(route) == catchall_prefix(new_route)
+            replaced_route = replace_brackets_with_keywords(route)
+            for rw, r, nr in zip(
+                replaced_route.split("/"), route.split("/"), new_route.split("/")
             ):
-                raise ValueError(
-                    f"You cannot use multiple catchall for the same dynamic route ({route} !== {new_route})"
-                )
+                if rw in segments and r != nr:
+                    # If the slugs in the segments of both routes are not the same, then the route is invalid
+                    raise ValueError(
+                        f"You cannot use different slug names for the same dynamic path in  {route} and {new_route} ('{r}' != '{nr}')"
+                    )
+                elif rw not in segments and r != nr:
+                    # if the section being compared in both routes is not a dynamic segment(i.e not wrapped in brackets)
+                    # then we are guaranteed that the route is valid and there's no need checking the rest.
+                    # eg. /posts/[id]/info/[slug1] and /posts/[id]/info1/[slug1] is always going to be valid since
+                    # info1 will break away into its own tree.
+                    break
 
     def add_custom_404_page(
         self,
@@ -568,7 +600,7 @@ class App(Base):
         """Define a custom 404 page for any url having no match.
 
         If there is no page defined on 'index' route, add the 404 page to it.
-        If there is no global catchall defined, add the 404 page with a catchall
+        If there is no global catchall defined, add the 404 page with a catchall.
 
         Args:
             component: The component to display at the page.
@@ -590,7 +622,7 @@ class App(Base):
             meta=meta,
         )
 
-    def setup_admin_dash(self):
+    def _setup_admin_dash(self):
         """Setup the admin dash."""
         # Get the admin dash.
         admin_dash = self.admin_dash
@@ -613,14 +645,14 @@ class App(Base):
 
             admin.mount_to(self.api)
 
-    def get_frontend_packages(self, imports: Dict[str, set[ImportVar]]):
+    def _get_frontend_packages(self, imports: Dict[str, set[ImportVar]]):
         """Gets the frontend packages to be installed and filters out the unnecessary ones.
 
         Args:
             imports: A dictionary containing the imports used in the current page.
 
         Example:
-            >>> get_frontend_packages({"react": "16.14.0", "react-dom": "16.14.0"})
+            >>> _get_frontend_packages({"react": "16.14.0", "react-dom": "16.14.0"})
         """
         page_imports = {
             i
@@ -703,19 +735,6 @@ class App(Base):
         for k, component in self.pages.items():
             self.pages[k] = self._add_overlay_to_component(component)
 
-    def compile(self):
-        """compile_() is the new function for performing compilation.
-        Reflex framework will call it automatically as needed.
-        """
-        console.deprecate(
-            feature_name="app.compile()",
-            reason="Explicit calls to app.compile() are not needed."
-            " Method will be removed in 0.4.0",
-            deprecation_version="0.3.8",
-            removal_version="0.5.0",
-        )
-        return
-
     def _apply_decorated_pages(self):
         """Add @rx.page decorated pages to the app.
 
@@ -726,10 +745,10 @@ class App(Base):
         This can move back into `compile_` when py39 support is dropped.
         """
         # Add the @rx.page decorated pages to collect on_load events.
-        for render, kwargs in DECORATED_PAGES:
+        for render, kwargs in DECORATED_PAGES[get_config().app_name]:
             self.add_page(render, **kwargs)
 
-    def compile_(self, export: bool = False):
+    def _compile(self, export: bool = False):
         """Compile the app and output it to the pages folder.
 
         Args:
@@ -743,7 +762,7 @@ class App(Base):
             self.add_custom_404_page()
 
         # Add the optional endpoints (_upload)
-        self.add_optional_endpoints()
+        self._add_optional_endpoints()
 
         if not self._should_compile():
             return
@@ -794,9 +813,7 @@ class App(Base):
 
         for _route, component in self.pages.items():
             # Merge the component style with the app style.
-            component._add_style_recursive(self.style)
-
-            component.apply_theme(self.theme)
+            component._add_style_recursive(self.style, self.theme)
 
             # Add component._get_all_imports() to all_imports.
             all_imports.update(component._get_all_imports())
@@ -941,7 +958,7 @@ class App(Base):
         progress.stop()
 
         # Install frontend packages.
-        self.get_frontend_packages(all_imports)
+        self._get_frontend_packages(all_imports)
 
         # Setup the next.config.js
         transpile_packages = [
@@ -1016,7 +1033,7 @@ class App(Base):
                 handler=handler, state=substate, payload=event.payload
             ):
                 # Postprocess the event.
-                update = await self.postprocess(state, event, update)
+                update = await self._postprocess(state, event, update)
 
                 # Send the update to the client.
                 await self.event_namespace.emit_update(
@@ -1067,7 +1084,7 @@ async def process(
             state.router = RouterData(router_data)
 
         # Preprocess the event.
-        update = await app.preprocess(state, event)
+        update = await app._preprocess(state, event)
 
         # If there was an update, yield it.
         if update is not None:
@@ -1083,7 +1100,7 @@ async def process(
             # Process the event synchronously.
             async for update in state._process(event):
                 # Postprocess the event.
-                update = await app.postprocess(state, event, update)
+                update = await app._postprocess(state, event, update)
 
                 # Yield the update.
                 yield update
@@ -1204,7 +1221,7 @@ def upload(app: App):
             async with app.state_manager.modify_state(event.substate_token) as state:
                 async for update in state._process(event):
                     # Postprocess the event.
-                    update = await app.postprocess(state, event, update)
+                    update = await app._postprocess(state, event, update)
                     yield update.json() + "\n"
 
         # Stream updates to client

reflex/app_module_for_backend.py

@@ -15,7 +15,7 @@ app = getattr(app_module, constants.CompileVars.APP)
 # For py3.8 and py3.9 compatibility when redis is used, we MUST add any decorator pages
 # before compiling the app in a thread to avoid event loop error (REF-2172).
 app._apply_decorated_pages()
-compile_future = ThreadPoolExecutor(max_workers=1).submit(app.compile_)
+compile_future = ThreadPoolExecutor(max_workers=1).submit(app._compile)
 compile_future.add_done_callback(
     # Force background compile errors to print eagerly
     lambda f: f.result()

reflex/base.py

@@ -5,19 +5,14 @@ import os
 from typing import TYPE_CHECKING, Any, List, Type
 
 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
-        from pydantic.v1 import BaseModel
-        from pydantic.v1.fields import ModelField
-    else:
-        raise ModuleNotFoundError
+    import pydantic.v1 as pydantic
+    from pydantic.v1 import BaseModel
+    from pydantic.v1.fields import ModelField
 except ModuleNotFoundError:
-    import pydantic
-    from pydantic import BaseModel
-    from pydantic.fields import ModelField
+    if not TYPE_CHECKING:
+        import pydantic
+        from pydantic import BaseModel
+        from pydantic.fields import ModelField  # type: ignore
 
 
 from reflex import constants
@@ -50,7 +45,7 @@ def validate_field_name(bases: List[Type["BaseModel"]], field_name: str) -> None
 pydantic.main.validate_field_name = validate_field_name  # type: ignore
 
 
-class Base(pydantic.BaseModel):
+class Base(pydantic.BaseModel):  # pyright: ignore [reportUnboundVariable]
     """The base class subclassed by all Reflex classes.
 
     This class wraps Pydantic and provides common methods such as
@@ -75,7 +70,10 @@ class Base(pydantic.BaseModel):
         """
         from reflex.utils.serializers import serialize
 
-        return self.__config__.json_dumps(self.dict(), default=serialize)
+        return self.__config__.json_dumps(  # type: ignore
+            self.dict(),
+            default=serialize,
+        )
 
     def set(self, **kwargs):
         """Set multiple fields and return the object.
@@ -114,7 +112,7 @@ class Base(pydantic.BaseModel):
             value=default_value,
             annotation=var._var_type,
             class_validators=None,
-            config=cls.__config__,
+            config=cls.__config__,  # type: ignore
         )
         cls.__fields__.update({var._var_name: new_field})
 

reflex/compiler/compiler.py

@@ -174,7 +174,7 @@ def _compile_root_stylesheet(stylesheets: list[str]) -> str:
     return templates.STYLE.render(stylesheets=sheets)
 
 
-def _compile_component(component: Component) -> str:
+def _compile_component(component: Component | StatefulComponent) -> str:
     """Compile a single component.
 
     Args:
@@ -263,9 +263,18 @@ def _compile_stateful_components(
             # Reset this flag to render the actual component.
             component.rendered_as_shared = False
 
+            # Include dynamic imports in the shared component.
+            if dynamic_imports := component._get_all_dynamic_imports():
+                rendered_components.update(
+                    {dynamic_import: None for dynamic_import in dynamic_imports}
+                )
+
+            # Include custom code in the shared component.
             rendered_components.update(
                 {code: None for code in component._get_all_custom_code()},
             )
+
+            # Include all imports in the shared component.
             all_import_dicts.append(component._get_all_imports())
 
             # Indicate that this component now imports from the shared file.