reflex 0.6.8a2__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

reflex/experimental/__init__.py

@@ -9,21 +9,29 @@ from reflex.components.sonner.toast import toast as toast
 
 from ..utils.console import warn
 from . import hooks as hooks
-from .assets import asset as asset
 from .client_state import ClientStateVar as ClientStateVar
 from .layout import layout as layout
 from .misc import run_in_thread as run_in_thread
 
-warn(
-    "`rx._x` contains experimental features and might be removed at any time in the future .",
-)
-
-_EMITTED_PROMOTION_WARNINGS = set()
-
 
 class ExperimentalNamespace(SimpleNamespace):
     """Namespace for experimental features."""
 
+    def __getattribute__(self, item: str):
+        """Get attribute from the namespace.
+
+        Args:
+            item: attribute name.
+
+        Returns:
+            The attribute.
+        """
+        warn(
+            "`rx._x` contains experimental features and might be removed at any time in the future.",
+            dedupe=True,
+        )
+        return super().__getattribute__(item)
+
     @property
     def toast(self):
         """Temporary property returning the toast namespace.
@@ -56,13 +64,13 @@ class ExperimentalNamespace(SimpleNamespace):
         Args:
              component_name: name of the component.
         """
-        if component_name not in _EMITTED_PROMOTION_WARNINGS:
-            _EMITTED_PROMOTION_WARNINGS.add(component_name)
-            warn(f"`rx._x.{component_name}` was promoted to `rx.{component_name}`.")
+        warn(
+            f"`rx._x.{component_name}` was promoted to `rx.{component_name}`.",
+            dedupe=True,
+        )
 
 
 _x = ExperimentalNamespace(
-    asset=asset,
     client_state=ClientStateVar.create,
     hooks=hooks,
     layout=layout,

reflex/experimental/client_state.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import dataclasses
 import re
-import sys
 from typing import Any, Callable, Union
 
 from reflex import constants
@@ -34,10 +33,22 @@ def _client_state_ref(var_name: str) -> str:
     return f"refs['_client_state_{var_name}']"
 
 
+def _client_state_ref_dict(var_name: str) -> str:
+    """Get the ref path for a ClientStateVar.
+
+    Args:
+        var_name: The name of the variable.
+
+    Returns:
+        An accessor for ClientStateVar ref as a string.
+    """
+    return f"refs['_client_state_dict_{var_name}']"
+
+
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
-    **{"slots": True} if sys.version_info >= (3, 10) else {},
+    slots=True,
 )
 class ClientStateVar(Var):
     """A Var that exists on the client via useState."""
@@ -115,10 +126,41 @@ class ClientStateVar(Var):
             "react": [ImportVar(tag="useState"), ImportVar(tag="useId")],
         }
         if global_ref:
-            hooks[f"{_client_state_ref(var_name)} ??= {{}}"] = None
-            hooks[f"{_client_state_ref(setter_name)} ??= {{}}"] = None
-            hooks[f"{_client_state_ref(var_name)}[{id_name}] = {var_name}"] = None
-            hooks[f"{_client_state_ref(setter_name)}[{id_name}] = {setter_name}"] = None
+            arg_name = get_unique_variable_name()
+            func = ArgsFunctionOperationBuilder.create(
+                args_names=(arg_name,),
+                return_expr=Var("Array.prototype.forEach.call")
+                .to(FunctionVar)
+                .call(
+                    (
+                        Var("Object.values")
+                        .to(FunctionVar)
+                        .call(Var(_client_state_ref_dict(setter_name)))
+                        .to(list)
+                        .to(list)
+                    )
+                    + Var.create(
+                        [
+                            Var(
+                                f"(value) => {{ {_client_state_ref(var_name)} = value; }}"
+                            )
+                        ]
+                    ).to(list),
+                    ArgsFunctionOperationBuilder.create(
+                        args_names=("setter",),
+                        return_expr=Var("setter").to(FunctionVar).call(Var(arg_name)),
+                    ),
+                ),
+            )
+
+            hooks[f"{_client_state_ref(setter_name)} = {func!s}"] = None
+            hooks[f"{_client_state_ref(var_name)} ??= {var_name!s}"] = None
+            hooks[f"{_client_state_ref_dict(var_name)} ??= {{}}"] = None
+            hooks[f"{_client_state_ref_dict(setter_name)} ??= {{}}"] = None
+            hooks[f"{_client_state_ref_dict(var_name)}[{id_name}] = {var_name}"] = None
+            hooks[
+                f"{_client_state_ref_dict(setter_name)}[{id_name}] = {setter_name}"
+            ] = None
             imports.update(_refs_import)
         return cls(
             _js_expr="",
@@ -150,7 +192,7 @@ class ClientStateVar(Var):
         return (
             Var(
                 _js_expr=(
-                    _client_state_ref(self._getter_name) + f"[{self._id_name}]"
+                    _client_state_ref_dict(self._getter_name) + f"[{self._id_name}]"
                     if self._global_ref
                     else self._getter_name
                 ),
@@ -158,9 +200,7 @@ class ClientStateVar(Var):
             )
             .to(self._var_type)
             ._replace(
-                merge_var_data=VarData(  # type: ignore
-                    imports=_refs_import if self._global_ref else {}
-                )
+                merge_var_data=VarData(imports=_refs_import if self._global_ref else {})
             )
         )
 
@@ -179,26 +219,11 @@ class ClientStateVar(Var):
         """
         _var_data = VarData(imports=_refs_import if self._global_ref else {})
 
-        arg_name = get_unique_variable_name()
         setter = (
-            ArgsFunctionOperationBuilder.create(
-                args_names=(arg_name,),
-                return_expr=Var("Array.prototype.forEach.call")
-                .to(FunctionVar)
-                .call(
-                    Var("Object.values")
-                    .to(FunctionVar)
-                    .call(Var(_client_state_ref(self._setter_name))),
-                    ArgsFunctionOperationBuilder.create(
-                        args_names=("setter",),
-                        return_expr=Var("setter").to(FunctionVar).call(Var(arg_name)),
-                    ),
-                ),
-                _var_data=_var_data,
-            )
+            Var(_client_state_ref(self._setter_name))
             if self._global_ref
-            else Var(self._setter_name, _var_data=_var_data).to(FunctionVar)
-        )
+            else Var(self._setter_name, _var_data=_var_data)
+        ).to(FunctionVar)
 
         if value is not NoValue:
             # This is a hack to make it work like an EventSpec taking an arg

reflex/experimental/hooks.py

@@ -11,7 +11,7 @@ def _compose_react_imports(tags: list[str]) -> dict[str, list[ImportVar]]:
     return {"react": [ImportVar(tag=tag) for tag in tags]}
 
 
-def const(name, value) -> Var:
+def const(name: str | list[str], value: str | Var) -> Var:
     """Create a constant Var.
 
     Args:
@@ -26,7 +26,7 @@ def const(name, value) -> Var:
     return Var(_js_expr=f"const {name} = {value}")
 
 
-def useCallback(func, deps) -> Var:
+def useCallback(func: str, deps: list) -> Var:  # noqa: N802
     """Create a useCallback hook with a function and dependencies.
 
     Args:
@@ -42,7 +42,7 @@ def useCallback(func, deps) -> Var:
     )
 
 
-def useContext(context) -> Var:
+def useContext(context: str) -> Var:  # noqa: N802
     """Create a useContext hook with a context.
 
     Args:
@@ -57,7 +57,7 @@ def useContext(context) -> Var:
     )
 
 
-def useRef(default) -> Var:
+def useRef(default: str) -> Var:  # noqa: N802
     """Create a useRef hook with a default value.
 
     Args:
@@ -72,7 +72,7 @@ def useRef(default) -> Var:
     )
 
 
-def useState(var_name, default=None) -> Var:
+def useState(var_name: str, default: str | None = None) -> Var:  # noqa: N802
     """Create a useState hook with a variable name and setter name.
 
     Args:

reflex/experimental/layout.py

@@ -12,6 +12,7 @@ from reflex.components.radix.themes.components.icon_button import IconButton
 from reflex.components.radix.themes.layout.box import Box
 from reflex.components.radix.themes.layout.container import Container
 from reflex.components.radix.themes.layout.stack import HStack
+from reflex.constants.compiler import MemoizationMode
 from reflex.event import run_script
 from reflex.experimental import hooks
 from reflex.state import ComponentState
@@ -44,10 +45,10 @@ class Sidebar(Box, MemoizationLeaf):
         Returns:
             The style of the component.
         """
-        sidebar: Component = self.children[-2]  # type: ignore
-        spacer: Component = self.children[-1]  # type: ignore
+        sidebar: Component = self.children[-2]  # pyright: ignore [reportAssignmentType]
+        spacer: Component = self.children[-1]  # pyright: ignore [reportAssignmentType]
         open = (
-            self.State.open  # type: ignore
+            self.State.open  # pyright: ignore [reportAttributeAccessIssue]
             if self.State
             else Var(_js_expr="open")
         )
@@ -146,6 +147,8 @@ sidebar_trigger_style = {
 class SidebarTrigger(Fragment):
     """A component that renders the sidebar trigger."""
 
+    _memoization_mode = MemoizationMode(recursive=False)
+
     @classmethod
     def create(cls, sidebar: Component, **props):
         """Create the sidebar trigger component.
@@ -159,11 +162,11 @@ class SidebarTrigger(Fragment):
         """
         trigger_props = {**props, **sidebar_trigger_style}
 
-        inner_sidebar: Component = sidebar.children[0]  # type: ignore
+        inner_sidebar: Component = sidebar.children[0]  # pyright: ignore [reportAssignmentType]
         sidebar_width = inner_sidebar.style.get("width")
 
         if sidebar.State:
-            open, toggle = sidebar.State.open, sidebar.State.toggle  # type: ignore
+            open, toggle = sidebar.State.open, sidebar.State.toggle  # pyright: ignore [reportAttributeAccessIssue]
         else:
             open, toggle = (
                 Var(_js_expr="open"),

reflex/experimental/layout.pyi

@@ -109,7 +109,7 @@ class DrawerSidebar(DrawerRoot):
         snap_points: Optional[List[Union[float, str]]] = None,
         fade_from_index: Optional[Union[Var[int], int]] = None,
         scroll_lock_timeout: Optional[Union[Var[int], int]] = None,
-        preventScrollRestoration: Optional[Union[Var[bool], bool]] = None,
+        prevent_scroll_restoration: Optional[Union[Var[bool], bool]] = None,
         should_scale_background: Optional[Union[Var[bool], bool]] = None,
         close_threshold: Optional[Union[Var[float], float]] = None,
         as_child: Optional[Union[Var[bool], bool]] = None,

reflex/experimental/misc.py

@@ -1,16 +1,16 @@
 """Miscellaneous functions for the experimental package."""
 
 import asyncio
-from typing import Any
+from typing import Any, Callable
 
 
-async def run_in_thread(func) -> Any:
+async def run_in_thread(func: Callable) -> Any:
     """Run a function in a separate thread.
 
     To not block the UI event queue, run_in_thread must be inside inside a rx.event(background=True) decorated method.
 
     Args:
-        func (callable): The non-async function to run.
+        func: The non-async function to run.
 
     Raises:
         ValueError: If the function is an async function.

reflex/istate/wrappers.py

@@ -6,7 +6,7 @@ from reflex.istate.proxy import ReadOnlyStateProxy
 from reflex.state import _split_substate_key, _substate_key, get_state_manager
 
 
-async def get_state(token, state_cls: Any | None = None) -> ReadOnlyStateProxy:
+async def get_state(token: str, state_cls: Any | None = None) -> ReadOnlyStateProxy:
     """Get the instance of a state for a token.
 
     Args:

reflex/middleware/hydrate_middleware.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Optional
 from reflex import constants
 from reflex.event import Event, get_hydrate_event
 from reflex.middleware.middleware import Middleware
-from reflex.state import BaseState, StateUpdate
+from reflex.state import BaseState, StateUpdate, _resolve_delta
 
 if TYPE_CHECKING:
     from reflex.app import App
@@ -42,7 +42,7 @@ class HydrateMiddleware(Middleware):
         setattr(state, constants.CompileVars.IS_HYDRATED, False)
 
         # Get the initial state.
-        delta = state.dict()
+        delta = await _resolve_delta(state.dict())
         # since a full dict was captured, clean any dirtiness
         state._clean()
 

reflex/model.py

@@ -18,6 +18,7 @@ import sqlalchemy
 import sqlalchemy.exc
 import sqlalchemy.ext.asyncio
 import sqlalchemy.orm
+from alembic.runtime.migration import MigrationContext
 
 from reflex.base import Base
 from reflex.config import environment, get_config
@@ -242,7 +243,7 @@ class ModelRegistry:
         return metadata
 
 
-class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssues]
+class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssues,reportIncompatibleVariableOverride]
     """Base class to define a table in the database."""
 
     # The primary key for the table.
@@ -261,7 +262,7 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
         super().__init_subclass__()
 
     @classmethod
-    def _dict_recursive(cls, value):
+    def _dict_recursive(cls, value: Any):
         """Recursively serialize the relationship object(s).
 
         Args:
@@ -393,7 +394,11 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
         writer = alembic.autogenerate.rewriter.Rewriter()
 
         @writer.rewrites(alembic.operations.ops.AddColumnOp)
-        def render_add_column_with_server_default(context, revision, op):
+        def render_add_column_with_server_default(
+            context: MigrationContext,
+            revision: str | None,
+            op: Any,
+        ):
             # Carry the sqlmodel default as server_default so that newly added
             # columns get the desired default value in existing rows.
             if op.column.default is not None and op.column.server_default is None:
@@ -402,7 +407,7 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
                 )
             return op
 
-        def run_autogenerate(rev, context):
+        def run_autogenerate(rev: str, context: MigrationContext):
             revision_context.run_autogenerate(rev, context)
             return []
 
@@ -415,7 +420,7 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
                 connection=connection,
                 target_metadata=ModelRegistry.get_metadata(),
                 render_item=cls._alembic_render_item,
-                process_revision_directives=writer,  # type: ignore
+                process_revision_directives=writer,
                 compare_type=False,
                 render_as_batch=True,  # for sqlite compatibility
             )
@@ -444,7 +449,7 @@ class Model(Base, sqlmodel.SQLModel):  # pyright: ignore [reportGeneralTypeIssue
         """
         config, script_directory = cls._alembic_config()
 
-        def run_upgrade(rev, context):
+        def run_upgrade(rev: str, context: MigrationContext):
             return script_directory._upgrade_revs(to_rev, rev)
 
         with alembic.runtime.environment.EnvironmentContext(

reflex/page.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Dict, List
+from typing import Any, Callable, Dict, List
 
 from reflex.config import get_config
 from reflex.event import BASE_STATE, EventType
@@ -42,7 +42,7 @@ def page(
         The decorated function.
     """
 
-    def decorator(render_fn):
+    def decorator(render_fn: Callable):
         kwargs = {}
         if route:
             kwargs["route"] = route
@@ -66,7 +66,7 @@ def page(
     return decorator
 
 
-def get_decorated_pages(omit_implicit_routes=True) -> list[dict[str, Any]]:
+def get_decorated_pages(omit_implicit_routes: bool = True) -> list[dict[str, Any]]:
     """Get the decorated pages.
 
     Args:

reflex/reflex.py

@@ -17,7 +17,7 @@ from reflex.state import reset_disk_state_manager
 from reflex.utils import console, telemetry
 
 # Disable typer+rich integration for help panels
-typer.core.rich = None  # type: ignore
+typer.core.rich = None  # pyright: ignore [reportPrivateImportUsage]
 
 # Create the app.
 try:
@@ -26,6 +26,8 @@ except TypeError:
     # Fallback for older typer versions.
     cli = typer.Typer(add_completion=False)
 
+SHOW_BUILT_WITH_REFLEX_INFO = "https://reflex.dev/docs/hosting/reflex-branding/"
+
 # Get the config.
 config = get_config()
 
@@ -125,8 +127,8 @@ def _run(
     env: constants.Env = constants.Env.DEV,
     frontend: bool = True,
     backend: bool = True,
-    frontend_port: str = str(config.frontend_port),
-    backend_port: str = str(config.backend_port),
+    frontend_port: int = config.frontend_port,
+    backend_port: int = config.backend_port,
     backend_host: str = config.backend_host,
     loglevel: constants.LogLevel = config.loglevel,
 ):
@@ -160,18 +162,22 @@ def _run(
     # Find the next available open port if applicable.
     if frontend:
         frontend_port = processes.handle_port(
-            "frontend", frontend_port, str(constants.DefaultPorts.FRONTEND_PORT)
+            "frontend",
+            frontend_port,
+            constants.DefaultPorts.FRONTEND_PORT,
         )
 
     if backend:
         backend_port = processes.handle_port(
-            "backend", backend_port, str(constants.DefaultPorts.BACKEND_PORT)
+            "backend",
+            backend_port,
+            constants.DefaultPorts.BACKEND_PORT,
         )
 
     # Apply the new ports to the config.
-    if frontend_port != str(config.frontend_port):
+    if frontend_port != config.frontend_port:
         config._set_persistent(frontend_port=frontend_port)
-    if backend_port != str(config.backend_port):
+    if backend_port != config.backend_port:
         config._set_persistent(backend_port=backend_port)
 
     # Reload the config to make sure the env vars are persistent.
@@ -182,6 +188,15 @@ def _run(
     prerequisites.check_latest_package_version(constants.Reflex.MODULE_NAME)
 
     if frontend:
+        if not config.show_built_with_reflex:
+            # The sticky badge may be disabled at runtime for team/enterprise tiers.
+            prerequisites.check_config_option_in_tier(
+                option_name="show_built_with_reflex",
+                allowed_tiers=["team", "enterprise"],
+                fallback_value=True,
+                help_link=SHOW_BUILT_WITH_REFLEX_INFO,
+            )
+
         # Get the app module.
         prerequisites.get_compiled_app()
 
@@ -262,10 +277,10 @@ def run(
         help="Execute only backend.",
         envvar=environment.REFLEX_BACKEND_ONLY.name,
     ),
-    frontend_port: str = typer.Option(
+    frontend_port: int = typer.Option(
         config.frontend_port, help="Specify a different frontend port."
     ),
-    backend_port: str = typer.Option(
+    backend_port: int = typer.Option(
         config.backend_port, help="Specify a different backend port."
     ),
     backend_host: str = typer.Option(
@@ -306,6 +321,9 @@ def export(
         help="Whether to exclude sqlite db files when exporting backend.",
         hidden=True,
     ),
+    env: constants.Env = typer.Option(
+        constants.Env.PROD, help="The environment to export the app in."
+    ),
     loglevel: constants.LogLevel = typer.Option(
         config.loglevel, help="The log level to use."
     ),
@@ -317,12 +335,22 @@ def export(
     if prerequisites.needs_reinit(frontend=True):
         _init(name=config.app_name, loglevel=loglevel)
 
+    if frontend and not config.show_built_with_reflex:
+        # The sticky badge may be disabled on export for team/enterprise tiers.
+        prerequisites.check_config_option_in_tier(
+            option_name="show_built_with_reflex",
+            allowed_tiers=["team", "enterprise"],
+            fallback_value=False,
+            help_link=SHOW_BUILT_WITH_REFLEX_INFO,
+        )
+
     export_utils.export(
         zipping=zipping,
         frontend=frontend,
         backend=backend,
         zip_dest_dir=zip_dest_dir,
         upload_db_file=upload_db_file,
+        env=env,
         loglevel=loglevel.subprocess_level(),
     )
 
@@ -351,7 +379,7 @@ def logout(
 
     check_version()
 
-    logout(loglevel)  # type: ignore
+    logout(loglevel)  # pyright: ignore [reportArgumentType]
 
 
 db_cli = typer.Typer()
@@ -440,7 +468,11 @@ def deploy(
         config.app_name,
         "--app-name",
         help="The name of the App to deploy under.",
-        hidden=True,
+    ),
+    app_id: str = typer.Option(
+        None,
+        "--app-id",
+        help="The ID of the App to deploy over.",
     ),
     regions: List[str] = typer.Option(
         [],
@@ -480,6 +512,11 @@ def deploy(
         "--project",
         help="project id to deploy to",
     ),
+    project_name: Optional[str] = typer.Option(
+        None,
+        "--project-name",
+        help="The name of the project to deploy to.",
+    ),
     token: Optional[str] = typer.Option(
         None,
         "--token",
@@ -492,6 +529,7 @@ def deploy(
     ),
 ):
     """Deploy the app to the Reflex hosting service."""
+    from reflex_cli.constants.base import LogLevel as HostingLogLevel
     from reflex_cli.utils import dependency
     from reflex_cli.v2 import cli as hosting_cli
 
@@ -500,15 +538,32 @@ def deploy(
 
     check_version()
 
+    if not config.show_built_with_reflex:
+        # The sticky badge may be disabled on deploy for pro/team/enterprise tiers.
+        prerequisites.check_config_option_in_tier(
+            option_name="show_built_with_reflex",
+            allowed_tiers=["pro", "team", "enterprise"],
+            fallback_value=True,
+            help_link=SHOW_BUILT_WITH_REFLEX_INFO,
+        )
+
     # Set the log level.
     console.set_log_level(loglevel)
 
-    if not token:
-        # make sure user is logged in.
-        if interactive:
-            hosting_cli.login()
-        else:
-            raise SystemExit("Token is required for non-interactive mode.")
+    def convert_reflex_loglevel_to_reflex_cli_loglevel(
+        loglevel: constants.LogLevel,
+    ) -> HostingLogLevel:
+        if loglevel == constants.LogLevel.DEBUG:
+            return HostingLogLevel.DEBUG
+        if loglevel == constants.LogLevel.INFO:
+            return HostingLogLevel.INFO
+        if loglevel == constants.LogLevel.WARNING:
+            return HostingLogLevel.WARNING
+        if loglevel == constants.LogLevel.ERROR:
+            return HostingLogLevel.ERROR
+        if loglevel == constants.LogLevel.CRITICAL:
+            return HostingLogLevel.CRITICAL
+        return HostingLogLevel.INFO
 
     # Only check requirements if interactive.
     # There is user interaction for requirements update.
@@ -522,6 +577,7 @@ def deploy(
 
     hosting_cli.deploy(
         app_name=app_name,
+        app_id=app_id,
         export_fn=lambda zip_dest_dir,
         api_url,
         deploy_url,
@@ -542,13 +598,28 @@ def deploy(
         envfile=envfile,
         hostname=hostname,
         interactive=interactive,
-        loglevel=type(loglevel).INFO,  # type: ignore
+        loglevel=convert_reflex_loglevel_to_reflex_cli_loglevel(loglevel),
         token=token,
         project=project,
-        config_path=config_path,
+        project_name=project_name,
+        **({"config_path": config_path} if config_path is not None else {}),
     )
 
 
+@cli.command()
+def rename(
+    new_name: str = typer.Argument(..., help="The new name for the app."),
+    loglevel: constants.LogLevel = typer.Option(
+        config.loglevel, help="The log level to use."
+    ),
+):
+    """Rename the app in the current directory."""
+    from reflex.utils import prerequisites
+
+    prerequisites.validate_app_name(new_name)
+    prerequisites.rename_app(new_name, loglevel)
+
+
 cli.add_typer(db_cli, name="db", help="Subcommands for managing the database schema.")
 cli.add_typer(script_cli, name="script", help="Subcommands running helper scripts.")
 cli.add_typer(

reflex/route.py

@@ -103,7 +103,7 @@ def catchall_prefix(route: str) -> str:
     return route.replace(pattern, "") if pattern else ""
 
 
-def replace_brackets_with_keywords(input_string):
+def replace_brackets_with_keywords(input_string: str) -> str:
     """Replace brackets and everything inside it in a string with a keyword.
 
     Args: