reflex 0.8.15a2__py3-none-any.whl → 0.8.16__py3-none-any.whl

reflex/app.py

@@ -11,6 +11,7 @@ import functools
 import inspect
 import io
 import json
+import operator
 import sys
 import time
 import traceback
@@ -118,6 +119,7 @@ from reflex.utils.exec import (
     should_prerender_routes,
 )
 from reflex.utils.imports import ImportVar
+from reflex.utils.misc import run_in_thread
 from reflex.utils.token_manager import TokenManager
 from reflex.utils.types import ASGIApp, Message, Receive, Scope, Send
 
@@ -849,7 +851,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
         # 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
+        state = self._state or State
         state.setup_dynamic_args(get_route_args(route))
 
         self._load_events[route] = (
@@ -969,14 +971,10 @@ class App(MiddlewareMixin, LifespanMixin):
 
         if admin_dash and admin_dash.models:
             # Build the admin dashboard
-            admin = (
-                admin_dash.admin
-                if admin_dash.admin
-                else Admin(
-                    engine=Model.get_db_engine(),
-                    title="Reflex Admin Dashboard",
-                    logo_url="https://reflex.dev/Reflex.svg",
-                )
+            admin = admin_dash.admin or Admin(
+                engine=Model.get_db_engine(),
+                title="Reflex Admin Dashboard",
+                logo_url="https://reflex.dev/Reflex.svg",
             )
 
             for model in admin_dash.models:
@@ -1009,21 +1007,21 @@ class App(MiddlewareMixin, LifespanMixin):
         page_imports = {i for i in page_imports if i not in pinned}
 
         frontend_packages = get_config().frontend_packages
-        _frontend_packages = []
+        filtered_frontend_packages = []
         for package in frontend_packages:
             if package in page_imports:
                 console.warn(
                     f"React packages and their dependencies are inferred from Component.library and Component.lib_dependencies, remove `{package}` from `frontend_packages`"
                 )
                 continue
-            _frontend_packages.append(package)
-        page_imports.update(_frontend_packages)
+            filtered_frontend_packages.append(package)
+        page_imports.update(filtered_frontend_packages)
         js_runtimes.install_frontend_packages(page_imports, get_config())
 
     def _app_root(self, app_wrappers: dict[tuple[int, str], Component]) -> Component:
         for component in tuple(app_wrappers.values()):
             app_wrappers.update(component._get_all_app_wrap_components())
-        order = sorted(app_wrappers, key=lambda k: k[0], reverse=True)
+        order = sorted(app_wrappers, key=operator.itemgetter(0), reverse=True)
         root = copy.deepcopy(app_wrappers[order[0]])
 
         def reducer(parent: Component, key: tuple[int, str]) -> Component:
@@ -1095,7 +1093,7 @@ class App(MiddlewareMixin, LifespanMixin):
             sticky_badge._add_style_recursive({})
             return sticky_badge
 
-        self.app_wraps[(0, "StickyBadge")] = lambda _: memoized_badge()
+        self.app_wraps[0, "StickyBadge"] = lambda _: memoized_badge()
 
     def _apply_decorated_pages(self):
         """Add @rx.page decorated pages to the app."""
@@ -1190,13 +1188,13 @@ class App(MiddlewareMixin, LifespanMixin):
 
         if self.theme is not None:
             # If a theme component was provided, wrap the app with it
-            app_wrappers[(20, "Theme")] = self.theme
+            app_wrappers[20, "Theme"] = self.theme
 
         # Get the env mode.
         config = get_config()
 
         if config.react_strict_mode:
-            app_wrappers[(200, "StrictMode")] = StrictMode.create()
+            app_wrappers[200, "StrictMode"] = StrictMode.create()
 
         if not should_compile and not dry_run:
             with console.timing("Evaluate Pages (Backend)"):
@@ -1251,7 +1249,7 @@ class App(MiddlewareMixin, LifespanMixin):
                 + "\n".join(
                     f"{route}: {time * 1000:.1f}ms"
                     for route, time in sorted(
-                        performance_metrics, key=lambda x: x[1], reverse=True
+                        performance_metrics, key=operator.itemgetter(1), reverse=True
                     )[:10]
                 )
             )
@@ -1295,7 +1293,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
             toast_provider = Fragment.create(memoized_toast_provider())
 
-            app_wrappers[(44, "ToasterProvider")] = toast_provider
+            app_wrappers[44, "ToasterProvider"] = toast_provider
 
         # Add the app wraps to the app.
         for key, app_wrap in chain(
@@ -1427,12 +1425,10 @@ class App(MiddlewareMixin, LifespanMixin):
                 plugin.pre_compile(
                     add_save_task=_submit_work_without_advancing,
                     add_modify_task=(
-                        lambda *args, plugin=plugin: modify_files_tasks.append(
-                            (
-                                plugin.__class__.__module__ + plugin.__class__.__name__,
-                                *args,
-                            )
-                        )
+                        lambda *args, plugin=plugin: modify_files_tasks.append((
+                            plugin.__class__.__module__ + plugin.__class__.__name__,
+                            *args,
+                        ))
                     ),
                     unevaluated_pages=list(self._unevaluated_pages.values()),
                 )
@@ -1552,7 +1548,7 @@ class App(MiddlewareMixin, LifespanMixin):
         if not self._api:
             return
 
-        async def all_routes(_request: Request) -> Response:
+        def all_routes(_request: Request) -> Response:
             return JSONResponse(list(self._unevaluated_pages.keys()))
 
         self._api.add_route(
@@ -1663,21 +1659,21 @@ class App(MiddlewareMixin, LifespanMixin):
             strict=True,
         ):
             if hasattr(handler_fn, "__name__"):
-                _fn_name = handler_fn.__name__
+                fn_name_ = handler_fn.__name__
             else:
-                _fn_name = type(handler_fn).__name__
+                fn_name_ = type(handler_fn).__name__
 
             if isinstance(handler_fn, functools.partial):
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is a partial function. Please provide a named function instead."
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is a partial function. Please provide a named function instead."
                 raise ValueError(msg)
 
             if not callable(handler_fn):
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is not a function."
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is not a function."
                 raise ValueError(msg)
 
             # Allow named functions only as lambda functions cannot be introspected
-            if _fn_name == "<lambda>":
-                msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` is a lambda function. Please use a named function instead."
+            if fn_name_ == "<lambda>":
+                msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` is a lambda function. Please use a named function instead."
                 raise ValueError(msg)
 
             # Check if the function has the necessary annotations and types in the right order
@@ -1690,18 +1686,18 @@ class App(MiddlewareMixin, LifespanMixin):
 
             for required_arg_index, required_arg in enumerate(handler_spec):
                 if required_arg not in arg_annotations:
-                    msg = f"Provided custom {handler_domain} exception handler `{_fn_name}` does not take the required argument `{required_arg}`"
+                    msg = f"Provided custom {handler_domain} exception handler `{fn_name_}` does not take the required argument `{required_arg}`"
                     raise ValueError(msg)
                 if list(arg_annotations.keys())[required_arg_index] != required_arg:
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong argument order."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong argument order."
                         f"Expected `{required_arg}` as the {required_arg_index + 1} argument but got `{list(arg_annotations.keys())[required_arg_index]}`"
                     )
                     raise ValueError(msg)
 
                 if not issubclass(arg_annotations[required_arg], Exception):
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong type for {required_arg} argument."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong type for {required_arg} argument."
                         f"Expected to be `Exception` but got `{arg_annotations[required_arg]}`"
                     )
                     raise ValueError(msg)
@@ -1725,7 +1721,7 @@ class App(MiddlewareMixin, LifespanMixin):
 
                 if not valid:
                     msg = (
-                        f"Provided custom {handler_domain} exception handler `{_fn_name}` has the wrong return type."
+                        f"Provided custom {handler_domain} exception handler `{fn_name_}` has the wrong return type."
                         f"Expected `EventSpec | list[EventSpec] | None` but got `{return_type}`"
                     )
                     raise ValueError(msg)
@@ -1754,15 +1750,13 @@ async def process(
     try:
         # Add request data to the state.
         router_data = event.router_data
-        router_data.update(
-            {
-                constants.RouteVar.QUERY: format.format_query_params(event.router_data),
-                constants.RouteVar.CLIENT_TOKEN: event.token,
-                constants.RouteVar.SESSION_ID: sid,
-                constants.RouteVar.HEADERS: headers,
-                constants.RouteVar.CLIENT_IP: client_ip,
-            }
-        )
+        router_data.update({
+            constants.RouteVar.QUERY: format.format_query_params(event.router_data),
+            constants.RouteVar.CLIENT_TOKEN: event.token,
+            constants.RouteVar.SESSION_ID: sid,
+            constants.RouteVar.HEADERS: headers,
+            constants.RouteVar.CLIENT_IP: client_ip,
+        })
         # Get the state for the session exclusively.
         async with app.state_manager.modify_state(event.substate_token) as state:
             # When this is a brand new instance of the state, signal the
@@ -1820,7 +1814,7 @@ async def process(
         raise
 
 
-async def ping(_request: Request) -> Response:
+def ping(_request: Request) -> Response:
     """Test API endpoint.
 
     Args:
@@ -1852,7 +1846,7 @@ async def health(_request: Request) -> JSONResponse:
     if prerequisites.check_db_used():
         from reflex.model import get_db_status
 
-        tasks.append(get_db_status())
+        tasks.append(run_in_thread(get_db_status))
     if prerequisites.check_redis_used():
         tasks.append(prerequisites.get_redis_status())
 

reflex/app_mixins/lifespan.py

@@ -41,13 +41,13 @@ class LifespanMixin(AppMixin):
                         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)
+                        t_ = task()
+                        if isinstance(t_, contextlib._AsyncGeneratorContextManager):
+                            await stack.enter_async_context(t_)
                             console.debug(run_msg.format(type="asynccontextmanager"))
-                        elif isinstance(_t, Coroutine):
+                        elif isinstance(t_, Coroutine):
                             task_ = asyncio.create_task(
-                                _t,
+                                t_,
                                 name=f"reflex_lifespan_task|{task_name}|{time.time()}",
                             )
                             task_.add_done_callback(lambda t: t.result())
@@ -71,6 +71,13 @@ class LifespanMixin(AppMixin):
                     await event_namespace._token_manager.disconnect_all()
             except Exception as e:
                 console.error(f"Error during lifespan cleanup: {e}")
+        # Flush any pending writes from the state manager.
+        try:
+            state_manager = self.state_manager  # pyright: ignore[reportAttributeAccessIssue]
+        except AttributeError:
+            pass
+        else:
+            await state_manager.close()
 
     def register_lifespan_task(self, task: Callable | asyncio.Task, **task_kwargs):
         """Register a task to run during the lifespan of the app.

reflex/base.py

@@ -48,6 +48,7 @@ if find_spec("pydantic") and find_spec("pydantic.v1"):
                 self.dict(),
                 default=serialize,
             )
+
 else:
 
     class PydanticNotFoundFallback:

reflex/compiler/compiler.py

@@ -758,12 +758,10 @@ def into_component(component: Component | ComponentCallable) -> Component:
                 raise TypeError(
                     "Cannot pass a Var to a built-in function. Consider using .length() for accessing the length of an iterable Var."
                 ).with_traceback(e.__traceback__) from None
-            if message.endswith(
-                (
-                    "indices must be integers or slices, not NumberCastedVar",
-                    "indices must be integers or slices, not BooleanCastedVar",
-                )
-            ):
+            if message.endswith((
+                "indices must be integers or slices, not NumberCastedVar",
+                "indices must be integers or slices, not BooleanCastedVar",
+            )):
                 raise TypeError(
                     "Cannot index into a primitive sequence with a Var. Consider calling rx.Var.create() on the sequence."
                 ).with_traceback(e.__traceback__) from None

reflex/compiler/templates.py

@@ -83,9 +83,9 @@ class _RenderUtils:
 
     @staticmethod
     def render_iterable_tag(component: Any) -> str:
-        children_rendered = "".join(
-            [_RenderUtils.render(child) for child in component.get("children", [])]
-        )
+        children_rendered = "".join([
+            _RenderUtils.render(child) for child in component.get("children", [])
+        ])
         return f"Array.prototype.map.call({component['iterable_state']} ?? [],(({component['arg_name']},{component['arg_index']})=>({children_rendered})))"
 
     @staticmethod
@@ -189,16 +189,14 @@ def app_root_template(
 
     custom_code_str = "\n".join(custom_codes)
 
-    import_window_libraries = "\n".join(
-        [
-            f'import * as {lib_alias} from "{lib_path}";'
-            for lib_alias, lib_path in window_libraries
-        ]
-    )
+    import_window_libraries = "\n".join([
+        f'import * as {lib_alias} from "{lib_path}";'
+        for lib_alias, lib_path in window_libraries
+    ])
 
-    window_imports_str = "\n".join(
-        [f'    "{lib_path}": {lib_alias},' for lib_alias, lib_path in window_libraries]
-    )
+    window_imports_str = "\n".join([
+        f'    "{lib_path}": {lib_alias},' for lib_alias, lib_path in window_libraries
+    ])
 
     return f"""
 {imports_str}
@@ -277,12 +275,10 @@ def context_template(
         Rendered context file content as string.
     """
     initial_state = initial_state or {}
-    state_contexts_str = "".join(
-        [
-            f"{format_state_name(state_name)}: createContext(null),"
-            for state_name in initial_state
-        ]
-    )
+    state_contexts_str = "".join([
+        f"{format_state_name(state_name)}: createContext(null),"
+        for state_name in initial_state
+    ])
 
     state_str = (
         rf"""
@@ -486,16 +482,14 @@ def package_json_template(
     Returns:
         Rendered package.json content as string.
     """
-    return json.dumps(
-        {
-            "name": "reflex",
-            "type": "module",
-            "scripts": scripts,
-            "dependencies": dependencies,
-            "devDependencies": dev_dependencies,
-            "overrides": overrides,
-        }
-    )
+    return json.dumps({
+        "name": "reflex",
+        "type": "module",
+        "scripts": scripts,
+        "dependencies": dependencies,
+        "devDependencies": dev_dependencies,
+        "overrides": overrides,
+    })
 
 
 def vite_config_template(base: str, hmr: bool, force_full_reload: bool):
@@ -693,9 +687,9 @@ def styles_template(stylesheets: list[str]) -> str:
     Returns:
         Rendered styles.css content as string.
     """
-    return "@layer __reflex_base;\n" + "\n".join(
-        [f"@import url('{sheet_name}');" for sheet_name in stylesheets]
-    )
+    return "@layer __reflex_base;\n" + "\n".join([
+        f"@import url('{sheet_name}');" for sheet_name in stylesheets
+    ])
 
 
 def _render_hooks(hooks: dict[str, VarData | None], memo: list | None = None) -> str:

reflex/compiler/utils.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import concurrent.futures
+import operator
 import traceback
 from collections.abc import Mapping, Sequence
 from datetime import datetime
@@ -161,7 +162,7 @@ def get_import_dict(
     return _ImportDict(
         lib=lib,
         default=default,
-        rest=rest if rest else [],
+        rest=rest or [],
     )
 
 
@@ -190,7 +191,7 @@ def _sorted_keys(d: Mapping[str, Any]) -> dict[str, Any]:
     Returns:
         A new dictionary with sorted keys.
     """
-    return dict(sorted(d.items(), key=lambda kv: kv[0]))
+    return dict(sorted(d.items(), key=operator.itemgetter(0)))
 
 
 def compile_state(state: type[BaseState]) -> dict:
@@ -442,9 +443,9 @@ def create_theme(style: ComponentStyle) -> dict:
 
     root_style = {
         # Root styles.
-        ":root": Style(
-            {f"*{k}": v for k, v in style_rules.items() if k.startswith(":")}
-        ),
+        ":root": Style({
+            f"*{k}": v for k, v in style_rules.items() if k.startswith(":")
+        }),
         # Body styles.
         "body": Style(
             {k: v for k, v in style_rules.items() if not k.startswith(":")},

reflex/components/base/body.pyi

@@ -4,7 +4,7 @@
 # This file was generated by `reflex/utils/pyi_generator.py`!
 # ------------------------------------------------------
 from collections.abc import Mapping, Sequence
-from typing import Any, Literal
+from typing import Any
 
 from reflex.components.core.breakpoints import Breakpoints
 from reflex.components.el import elements
@@ -16,184 +16,6 @@ class Body(elements.Body):
     def create(
         cls,
         *children,
-        access_key: Var[str] | str | None = None,
-        auto_capitalize: Literal[
-            "characters", "none", "off", "on", "sentences", "words"
-        ]
-        | Var[Literal["characters", "none", "off", "on", "sentences", "words"]]
-        | None = None,
-        content_editable: Literal["inherit", "plaintext-only", False, True]
-        | Var[Literal["inherit", "plaintext-only", False, True]]
-        | None = None,
-        context_menu: Var[str] | str | None = None,
-        dir: Var[str] | str | None = None,
-        draggable: Var[bool] | bool | None = None,
-        enter_key_hint: Literal[
-            "done", "enter", "go", "next", "previous", "search", "send"
-        ]
-        | Var[Literal["done", "enter", "go", "next", "previous", "search", "send"]]
-        | None = None,
-        hidden: Var[bool] | bool | None = None,
-        input_mode: Literal[
-            "decimal", "email", "none", "numeric", "search", "tel", "text", "url"
-        ]
-        | Var[
-            Literal[
-                "decimal", "email", "none", "numeric", "search", "tel", "text", "url"
-            ]
-        ]
-        | None = None,
-        item_prop: Var[str] | str | None = None,
-        lang: Var[str] | str | None = None,
-        role: Literal[
-            "alert",
-            "alertdialog",
-            "application",
-            "article",
-            "banner",
-            "button",
-            "cell",
-            "checkbox",
-            "columnheader",
-            "combobox",
-            "complementary",
-            "contentinfo",
-            "definition",
-            "dialog",
-            "directory",
-            "document",
-            "feed",
-            "figure",
-            "form",
-            "grid",
-            "gridcell",
-            "group",
-            "heading",
-            "img",
-            "link",
-            "list",
-            "listbox",
-            "listitem",
-            "log",
-            "main",
-            "marquee",
-            "math",
-            "menu",
-            "menubar",
-            "menuitem",
-            "menuitemcheckbox",
-            "menuitemradio",
-            "navigation",
-            "none",
-            "note",
-            "option",
-            "presentation",
-            "progressbar",
-            "radio",
-            "radiogroup",
-            "region",
-            "row",
-            "rowgroup",
-            "rowheader",
-            "scrollbar",
-            "search",
-            "searchbox",
-            "separator",
-            "slider",
-            "spinbutton",
-            "status",
-            "switch",
-            "tab",
-            "table",
-            "tablist",
-            "tabpanel",
-            "term",
-            "textbox",
-            "timer",
-            "toolbar",
-            "tooltip",
-            "tree",
-            "treegrid",
-            "treeitem",
-        ]
-        | Var[
-            Literal[
-                "alert",
-                "alertdialog",
-                "application",
-                "article",
-                "banner",
-                "button",
-                "cell",
-                "checkbox",
-                "columnheader",
-                "combobox",
-                "complementary",
-                "contentinfo",
-                "definition",
-                "dialog",
-                "directory",
-                "document",
-                "feed",
-                "figure",
-                "form",
-                "grid",
-                "gridcell",
-                "group",
-                "heading",
-                "img",
-                "link",
-                "list",
-                "listbox",
-                "listitem",
-                "log",
-                "main",
-                "marquee",
-                "math",
-                "menu",
-                "menubar",
-                "menuitem",
-                "menuitemcheckbox",
-                "menuitemradio",
-                "navigation",
-                "none",
-                "note",
-                "option",
-                "presentation",
-                "progressbar",
-                "radio",
-                "radiogroup",
-                "region",
-                "row",
-                "rowgroup",
-                "rowheader",
-                "scrollbar",
-                "search",
-                "searchbox",
-                "separator",
-                "slider",
-                "spinbutton",
-                "status",
-                "switch",
-                "tab",
-                "table",
-                "tablist",
-                "tabpanel",
-                "term",
-                "textbox",
-                "timer",
-                "toolbar",
-                "tooltip",
-                "tree",
-                "treegrid",
-                "treeitem",
-            ]
-        ]
-        | None = None,
-        slot: Var[str] | str | None = None,
-        spell_check: Var[bool] | bool | None = None,
-        tab_index: Var[int] | int | None = None,
-        title: Var[str] | str | None = None,
         style: Sequence[Mapping[str, Any]]
         | Mapping[str, Any]
         | Var[Mapping[str, Any]]
@@ -226,22 +48,6 @@ class Body(elements.Body):
 
         Args:
             *children: The children of the component.
-            access_key: Provides a hint for generating a keyboard shortcut for the current element.
-            auto_capitalize: Controls whether and how text input is automatically capitalized as it is entered/edited by the user.
-            content_editable: Indicates whether the element's content is editable.
-            context_menu: Defines the ID of a <menu> element which will serve as the element's context menu.
-            dir: Defines the text direction. Allowed values are ltr (Left-To-Right) or rtl (Right-To-Left)
-            draggable: Defines whether the element can be dragged.
-            enter_key_hint: Hints what media types the media element is able to play.
-            hidden: Defines whether the element is hidden.
-            input_mode: Defines the type of the element.
-            item_prop: Defines the name of the element for metadata purposes.
-            lang: Defines the language used in the element.
-            role: Defines the role of the element.
-            slot: Assigns a slot in a shadow DOM shadow tree to an element.
-            spell_check: Defines whether the element may be checked for spelling errors.
-            tab_index: Defines the position of the current element in the tabbing order.
-            title: Defines a tooltip for the element.
             style: The style of the component.
             key: A unique key for the component.
             id: The id for the component.