reflex 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

reflex/constants.py

@@ -1,6 +1,8 @@
 """Constants used throughout the package."""
+from __future__ import annotations
 
 import os
+import platform
 import re
 from enum import Enum
 from types import SimpleNamespace
@@ -43,14 +45,10 @@ def get_value(key: str, default: Any = None, type_: Type = str) -> Type:
 MODULE_NAME = "reflex"
 # The current version of Reflex.
 VERSION = metadata.version(MODULE_NAME)
-# Minimum version of Node.js required to run Reflex.
-MIN_NODE_VERSION = "16.8.0"
-
-# Valid bun versions.
-MIN_BUN_VERSION = "0.5.9"
-MAX_BUN_VERSION = "0.6.9"
 
 # Files and directories used to init a new project.
+# The directory to store reflex dependencies.
+REFLEX_DIR = os.path.expandvars(os.path.join("$HOME", f".{MODULE_NAME}"))
 # The root directory of the reflex library.
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 # The name of the assets directory.
@@ -64,6 +62,42 @@ ASSETS_TEMPLATE_DIR = os.path.join(TEMPLATE_DIR, APP_ASSETS_DIR)
 # The jinja template directory.
 JINJA_TEMPLATE_DIR = os.path.join(TEMPLATE_DIR, "jinja")
 
+# Bun config.
+# The Bun version.
+BUN_VERSION = "0.7.0"
+# The directory to store the bun.
+BUN_ROOT_PATH = os.path.join(REFLEX_DIR, ".bun")
+# The bun path.
+BUN_PATH = os.path.join(BUN_ROOT_PATH, "bin", "bun")
+# URL to bun install script.
+BUN_INSTALL_URL = "https://bun.sh/install"
+
+# NVM / Node config.
+# The NVM version.
+NVM_VERSION = "0.39.1"
+# The Node version.
+NODE_VERSION = "18.17.0"
+# The minimum required node version.
+NODE_VERSION_MIN = "16.8.0"
+# The directory to store nvm.
+NVM_DIR = os.path.join(REFLEX_DIR, ".nvm")
+# The nvm path.
+NVM_PATH = os.path.join(NVM_DIR, "nvm.sh")
+# The node bin path.
+NODE_BIN_PATH = os.path.join(NVM_DIR, "versions", "node", f"v{NODE_VERSION}", "bin")
+# The default path where node is installed.
+NODE_PATH = (
+    "node" if platform.system() == "Windows" else os.path.join(NODE_BIN_PATH, "node")
+)
+# The default path where npm is installed.
+NPM_PATH = (
+    "npm" if platform.system() == "Windows" else os.path.join(NODE_BIN_PATH, "npm")
+)
+# The URL to the nvm install script.
+NVM_INSTALL_URL = (
+    f"https://raw.githubusercontent.com/nvm-sh/nvm/v{NVM_VERSION}/install.sh"
+)
+
 # The frontend directories in a project.
 # The web folder where the NextJS app is compiled to.
 WEB_DIR = ".web"
@@ -110,12 +144,6 @@ BACKEND_PORT = get_value("BACKEND_PORT", "8000")
 API_URL = get_value("API_URL", "http://localhost:8000")
 # The deploy url
 DEPLOY_URL = get_value("DEPLOY_URL")
-# bun root location
-BUN_ROOT_PATH = "$HOME/.bun"
-# The default path where bun is installed.
-BUN_PATH = get_value("BUN_PATH", f"{BUN_ROOT_PATH}/bin/bun")
-# Command to install bun.
-INSTALL_BUN = f"curl -fsSL https://bun.sh/install | bash -s -- bun-v{MAX_BUN_VERSION}"
 # Default host in dev mode.
 BACKEND_HOST = get_value("BACKEND_HOST", "0.0.0.0")
 # The default timeout when launching the gunicorn server.
@@ -200,6 +228,11 @@ TOKEN_EXPIRATION = 60 * 60
 # The event namespace for websocket
 EVENT_NAMESPACE = get_value("EVENT_NAMESPACE")
 
+# Testing variables.
+# Testing os env set by pytest when running a test case.
+PYTEST_CURRENT_TEST = "PYTEST_CURRENT_TEST"
+
+
 # Env modes
 class Env(str, Enum):
     """The environment modes."""
@@ -218,6 +251,18 @@ class LogLevel(str, Enum):
     ERROR = "error"
     CRITICAL = "critical"
 
+    def __le__(self, other: LogLevel) -> bool:
+        """Compare log levels.
+
+        Args:
+            other: The other log level.
+
+        Returns:
+            True if the log level is less than or equal to the other log level.
+        """
+        levels = list(LogLevel)
+        return levels.index(self) <= levels.index(other)
+
 
 # Templates
 class Template(str, Enum):
@@ -328,6 +373,7 @@ class RouteVar(SimpleNamespace):
     CLIENT_TOKEN = "token"
     HEADERS = "headers"
     PATH = "pathname"
+    ORIGIN = "asPath"
     SESSION_ID = "sid"
     QUERY = "query"
     COOKIE = "cookie"
@@ -346,8 +392,7 @@ class RouteRegex(SimpleNamespace):
 
 
 # 404 variables
-ROOT_404 = ""
-SLUG_404 = "[..._]"
+SLUG_404 = "404"
 TITLE_404 = "404 - Not Found"
 FAVICON_404 = "favicon.ico"
 DESCRIPTION_404 = "The page was not found"

reflex/model.py

@@ -37,8 +37,8 @@ def get_engine(url: Optional[str] = None):
     if url is None:
         raise ValueError("No database url configured")
     if not Path(constants.ALEMBIC_CONFIG).exists():
-        console.print(
-            "[red]Database is not initialized, run [bold]reflex db init[/bold] first."
+        console.warn(
+            "Database is not initialized, run [bold]reflex db init[/bold] first."
         )
     echo_db_query = False
     if conf.env == constants.Env.DEV and constants.SQLALCHEMY_ECHO:

reflex/page.py

@@ -0,0 +1,66 @@
+"""The page decorator and associated variables and functions."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from reflex.components.component import Component
+from reflex.event import EventHandler
+
+DECORATED_PAGES = []
+
+
+def page(
+    route: Optional[str] = None,
+    title: Optional[str] = None,
+    image: Optional[str] = None,
+    description: Optional[str] = None,
+    meta: Optional[str] = None,
+    script_tags: Optional[List[Component]] = None,
+    on_load: Optional[Union[EventHandler, List[EventHandler]]] = None,
+):
+    """Decorate a function as a page.
+
+    rx.App() will automatically call add_page() for any method decorated with page
+    when App.compile is called.
+
+    All defaults are None because they will use the one from add_page().
+
+    Note: the decorated functions still need to be imported.
+
+    Args:
+        route: The route to reach the page.
+        title: The title of the page.
+        image: The favicon of the page.
+        description: The description of the page.
+        meta: Additionnal meta to add to the page.
+        on_load: The event handler(s) called when the page load.
+        script_tags: scripts to attach to the page
+
+    Returns:
+        The decorated function.
+    """
+    ...
+
+    def decorator(render_fn):
+        kwargs = {}
+        if route:
+            kwargs["route"] = route
+        if title:
+            kwargs["title"] = title
+        if image:
+            kwargs["image"] = image
+        if description:
+            kwargs["description"] = description
+        if meta:
+            kwargs["meta"] = meta
+        if script_tags:
+            kwargs["script_tags"] = script_tags
+        if on_load:
+            kwargs["on_load"] = on_load
+
+        DECORATED_PAGES.append((render_fn, kwargs))
+
+        return render_fn
+
+    return decorator

reflex/reflex.py

@@ -1,7 +1,6 @@
 """Reflex CLI to create, run, and deploy apps."""
 
 import os
-import platform
 import signal
 import threading
 from pathlib import Path
@@ -15,54 +14,79 @@ from reflex.config import get_config
 from reflex.utils import build, console, exec, prerequisites, processes, telemetry
 
 # Create the app.
-cli = typer.Typer()
+cli = typer.Typer(add_completion=False)
 
 
-@cli.command()
-def version():
-    """Get the Reflex version."""
-    console.print(constants.VERSION)
+def version(value: bool):
+    """Get the Reflex version.
+
+    Args:
+        value: Whether the version flag was passed.
+
+    Raises:
+        typer.Exit: If the version flag was passed.
+    """
+    if value:
+        console.print(constants.VERSION)
+        raise typer.Exit()
+
+
+@cli.callback()
+def main(
+    version: bool = typer.Option(
+        None,
+        "-v",
+        "--version",
+        callback=version,
+        help="Get the Reflex version.",
+        is_eager=True,
+    ),
+):
+    """Reflex CLI to create, run, and deploy apps."""
+    pass
 
 
 @cli.command()
 def init(
-    name: str = typer.Option(None, help="Name of the app to be initialized."),
+    name: str = typer.Option(
+        None, metavar="APP_NAME", help="The name of the app to be initialized."
+    ),
     template: constants.Template = typer.Option(
-        constants.Template.DEFAULT, help="Template to use for the app."
+        constants.Template.DEFAULT, help="The template to initialize the app with."
+    ),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
     ),
 ):
     """Initialize a new Reflex app in the current directory."""
-    app_name = prerequisites.get_default_app_name() if name is None else name
-
-    # Make sure they don't name the app "reflex".
-    if app_name == constants.MODULE_NAME:
-        console.print(
-            f"[red]The app directory cannot be named [bold]{constants.MODULE_NAME}."
-        )
-        raise typer.Exit()
+    # Set the log level.
+    console.set_log_level(loglevel)
 
+    # Get the app name.
+    app_name = prerequisites.get_default_app_name() if name is None else name
     console.rule(f"[bold]Initializing {app_name}")
-    # Set up the web directory.
-    prerequisites.validate_and_install_bun()
-    prerequisites.initialize_web_directory()
+
+    # Set up the web project.
+    prerequisites.initialize_frontend_dependencies()
 
     # Migrate Pynecone projects to Reflex.
     prerequisites.migrate_to_reflex()
 
     # Set up the app directory, only if the config doesn't exist.
+    config = get_config()
     if not os.path.exists(constants.CONFIG_FILE):
         prerequisites.create_config(app_name)
         prerequisites.initialize_app_directory(app_name, template)
         build.set_reflex_project_hash()
-        telemetry.send("init", get_config().telemetry_enabled)
+        telemetry.send("init", config.telemetry_enabled)
     else:
-        build.set_reflex_project_hash()
-        telemetry.send("reinit", get_config().telemetry_enabled)
+        telemetry.send("reinit", config.telemetry_enabled)
 
     # Initialize the .gitignore.
     prerequisites.initialize_gitignore()
+
     # Finish initializing the app.
-    console.log(f"[bold green]Finished Initializing: {app_name}")
+    console.success(f"Initialized {app_name}")
 
 
 @cli.command()
@@ -74,18 +98,17 @@ def run(
         False, "--frontend-only", help="Execute only frontend."
     ),
     backend: bool = typer.Option(False, "--backend-only", help="Execute only backend."),
-    loglevel: constants.LogLevel = typer.Option(
-        constants.LogLevel.ERROR, help="The log level to use."
-    ),
     frontend_port: str = typer.Option(None, help="Specify a different frontend port."),
     backend_port: str = typer.Option(None, help="Specify a different backend port."),
     backend_host: str = typer.Option(None, help="Specify the backend host."),
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
+    ),
 ):
     """Run the app in the current directory."""
-    if platform.system() == "Windows":
-        console.print(
-            "[yellow][WARNING] We strongly advise you to use Windows Subsystem for Linux (WSL) for optimal performance when using Reflex. Due to compatibility issues with one of our dependencies, Bun, you may experience slower performance on Windows. By using WSL, you can expect to see a significant speed increase."
-        )
+    # Set the log level.
+    console.set_log_level(loglevel)
+
     # Set ports as os env variables to take precedence over config and
     # .env variables(if override_os_envs flag in config is set to False).
     build.set_os_env(
@@ -94,17 +117,20 @@ def run(
         backend_host=backend_host,
     )
 
-    frontend_port = (
-        get_config().frontend_port if frontend_port is None else frontend_port
-    )
-    backend_port = get_config().backend_port if backend_port is None else backend_port
-    backend_host = get_config().backend_host if backend_host is None else backend_host
+    # Get the ports from the config.
+    config = get_config()
+    frontend_port = config.frontend_port if frontend_port is None else frontend_port
+    backend_port = config.backend_port if backend_port is None else backend_port
+    backend_host = config.backend_host if backend_host is None else backend_host
 
     # If no --frontend-only and no --backend-only, then turn on frontend and backend both
     if not frontend and not backend:
         frontend = True
         backend = True
 
+    # Check that the app is initialized.
+    prerequisites.check_initialized(frontend=frontend)
+
     # If something is running on the ports, ask the user if they want to kill or change it.
     if frontend and processes.is_process_on_port(frontend_port):
         frontend_port = processes.change_or_terminate_port(frontend_port, "frontend")
@@ -112,20 +138,6 @@ def run(
     if backend and processes.is_process_on_port(backend_port):
         backend_port = processes.change_or_terminate_port(backend_port, "backend")
 
-    # Check that the app is initialized.
-    if frontend and not prerequisites.is_initialized():
-        console.print(
-            "[red]The app is not initialized. Run [bold]reflex init[/bold] first."
-        )
-        raise typer.Exit()
-
-    # Check that the template is up to date.
-    if frontend and not prerequisites.is_latest_template():
-        console.print(
-            "[red]The base app template has updated. Run [bold]reflex init[/bold] again."
-        )
-        raise typer.Exit()
-
     # Get the app module.
     console.rule("[bold]Starting Reflex App")
     app = prerequisites.get_app()
@@ -153,18 +165,16 @@ def run(
     assert setup_frontend and frontend_cmd and backend_cmd, "Invalid env"
 
     # Post a telemetry event.
-    telemetry.send(f"run-{env.value}", get_config().telemetry_enabled)
+    telemetry.send(f"run-{env.value}", config.telemetry_enabled)
 
     # Run the frontend and backend.
     if frontend:
-        setup_frontend(Path.cwd(), loglevel)
-        threading.Thread(
-            target=frontend_cmd, args=(Path.cwd(), frontend_port, loglevel)
-        ).start()
+        setup_frontend(Path.cwd())
+        threading.Thread(target=frontend_cmd, args=(Path.cwd(), frontend_port)).start()
     if backend:
         threading.Thread(
             target=backend_cmd,
-            args=(app.__name__, backend_host, backend_port, loglevel),
+            args=(app.__name__, backend_host, backend_port),
         ).start()
 
     # Display custom message when there is a keyboard interrupt.
@@ -176,7 +186,6 @@ def deploy(dry_run: bool = typer.Option(False, help="Whether to run a dry run.")
     """Deploy the app to the Reflex hosting service."""
     # Get the app config.
     config = get_config()
-    config.api_url = prerequisites.get_production_backend_url()
 
     # Check if the deploy url is set.
     if config.rxdeploy_url is None:
@@ -185,7 +194,7 @@ def deploy(dry_run: bool = typer.Option(False, help="Whether to run a dry run.")
 
     # Compile the app in production mode.
     typer.echo("Compiling production app")
-    export(for_reflex_deploy=True)
+    export()
 
     # Exit early if this is a dry run.
     if dry_run:
@@ -217,29 +226,29 @@ def export(
     backend: bool = typer.Option(
         True, "--frontend-only", help="Export only frontend.", show_default=False
     ),
-    for_reflex_deploy: bool = typer.Option(
-        False,
-        "--for-reflex-deploy",
-        help="Whether export the app for Reflex Deploy Service.",
+    loglevel: constants.LogLevel = typer.Option(
+        constants.LogLevel.INFO, help="The log level to use."
     ),
 ):
     """Export the app to a zip file."""
-    config = get_config()
+    # Set the log level.
+    console.set_log_level(loglevel)
 
-    if for_reflex_deploy:
-        # Get the app config and modify the api_url base on username and app_name.
-        config.api_url = prerequisites.get_production_backend_url()
+    # Check that the app is initialized.
+    prerequisites.check_initialized(frontend=frontend)
 
     # Compile the app in production mode and export it.
     console.rule("[bold]Compiling production app and preparing for export.")
 
     if frontend:
-        # ensure module can be imported and app.compile() is called
+        # Ensure module can be imported and app.compile() is called.
         prerequisites.get_app()
-        # set up .web directory and install frontend dependencies
+        # Set up .web directory and install frontend dependencies.
         build.setup_frontend(Path.cwd())
 
-    build.export_app(
+    # Export the app.
+    config = get_config()
+    build.export(
         backend=backend,
         frontend=frontend,
         zip=zipping,
@@ -247,15 +256,15 @@ def export(
     )
 
     # Post a telemetry event.
-    telemetry.send("export", get_config().telemetry_enabled)
+    telemetry.send("export", config.telemetry_enabled)
 
     if zipping:
-        console.rule(
+        console.log(
             """Backend & Frontend compiled. See [green bold]backend.zip[/green bold]
             and [green bold]frontend.zip[/green bold]."""
         )
     else:
-        console.rule(
+        console.log(
             """Backend & Frontend compiled. See [green bold]app[/green bold]
             and [green bold].web/_static[/green bold] directories."""
         )
@@ -267,16 +276,22 @@ db_cli = typer.Typer()
 @db_cli.command(name="init")
 def db_init():
     """Create database schema and migration configuration."""
+    # Check the database url.
     if get_config().db_url is None:
-        console.print("[red]db_url is not configured, cannot initialize.")
+        console.error("db_url is not configured, cannot initialize.")
+        return
+
+    # Check the alembic config.
     if Path(constants.ALEMBIC_CONFIG).exists():
-        console.print(
-            "[red]Database is already initialized. Use "
+        console.error(
+            "Database is already initialized. Use "
             "[bold]reflex db makemigrations[/bold] to create schema change "
             "scripts and [bold]reflex db migrate[/bold] to apply migrations "
             "to a new or existing database.",
         )
         return
+
+    # Initialize the database.
     prerequisites.get_app()
     model.Model.alembic_init()
     model.Model.migrate(autogenerate=True)
@@ -308,13 +323,12 @@ def makemigrations(
         except CommandError as command_error:
             if "Target database is not up to date." not in str(command_error):
                 raise
-            console.print(
-                f"[red]{command_error} Run [bold]reflex db migrate[/bold] to update database."
+            console.error(
+                f"{command_error} Run [bold]reflex db migrate[/bold] to update database."
             )
 
 
-cli.add_typer(db_cli, name="db", help="Subcommands for managing the database schema")
-main = cli
+cli.add_typer(db_cli, name="db", help="Subcommands for managing the database schema.")
 
 if __name__ == "__main__":
-    main()
+    cli()

reflex/route.py

@@ -7,8 +7,8 @@ from typing import Dict, List, Optional, Union
 
 from reflex import constants
 from reflex.event import EventHandler
-
-DECORATED_ROUTES = []
+from reflex.page import page
+from reflex.utils.console import deprecate
 
 
 def route(
@@ -37,25 +37,15 @@ def route(
     Returns:
         The decorated function.
     """
-
-    def decorator(render_fn):
-        kwargs = {}
-        if route:
-            kwargs["route"] = route
-        if title:
-            kwargs["title"] = title
-        if image:
-            kwargs["image"] = image
-        if description:
-            kwargs["description"] = description
-        if on_load:
-            kwargs["on_load"] = on_load
-
-        DECORATED_ROUTES.append((render_fn, kwargs))
-
-        return render_fn
-
-    return decorator
+    deprecate("@rx.route is deprecated and is being replaced by @rx.page instead")
+
+    return page(
+        route=route,
+        title=title,
+        image=image,
+        description=description,
+        on_load=on_load,
+    )
 
 
 def verify_route_validity(route: str) -> None:

reflex/state.py

@@ -476,13 +476,19 @@ class State(Base, ABC, extra=pydantic.Extra.allow):
         """
         return self.router_data.get(constants.RouteVar.CLIENT_IP, "")
 
-    def get_current_page(self) -> str:
+    def get_current_page(self, origin=False) -> str:
         """Obtain the path of current page from the router data.
 
+        Args:
+            origin: whether to return the base route as shown in browser
+
         Returns:
             The current page.
         """
-        return self.router_data.get(constants.RouteVar.PATH, "")
+        if origin:
+            return self.router_data.get(constants.RouteVar.ORIGIN, "")
+        else:
+            return self.router_data.get(constants.RouteVar.PATH, "")
 
     def get_query_params(self) -> Dict[str, str]:
         """Obtain the query parameters for the queried page.
@@ -595,6 +601,10 @@ class State(Base, ABC, extra=pydantic.Extra.allow):
             self.mark_dirty()
             return
 
+        # Make sure lists and dicts are converted to ReflexList and ReflexDict.
+        if name in self.vars and types._isinstance(value, Union[List, Dict]):
+            value = _convert_mutable_datatypes(value, self._reassign_field, name)
+
         # Set the attribute.
         super().__setattr__(name, value)
 
@@ -730,8 +740,14 @@ class State(Base, ABC, extra=pydantic.Extra.allow):
 
             # Handle regular generators.
             elif inspect.isgenerator(events):
-                for event in events:
-                    yield event, False
+                try:
+                    while True:
+                        yield next(events), False
+                except StopIteration as si:
+                    # the "return" value of the generator is not available
+                    # in the loop, we must catch StopIteration to access it
+                    if si.value is not None:
+                        yield si.value, False
                 yield None, True
 
             # Handle regular event chains.
@@ -984,21 +1000,22 @@ def _convert_mutable_datatypes(
         The converted field_value
     """
     if isinstance(field_value, list):
-        for index in range(len(field_value)):
-            field_value[index] = _convert_mutable_datatypes(
-                field_value[index], reassign_field, field_name
-            )
+        field_value = [
+            _convert_mutable_datatypes(value, reassign_field, field_name)
+            for value in field_value
+        ]
 
         field_value = ReflexList(
             field_value, reassign_field=reassign_field, field_name=field_name
         )
 
     if isinstance(field_value, dict):
-        for key, value in field_value.items():
-            field_value[key] = _convert_mutable_datatypes(
-                value, reassign_field, field_name
-            )
+        field_value = {
+            key: _convert_mutable_datatypes(value, reassign_field, field_name)
+            for key, value in field_value.items()
+        }
         field_value = ReflexDict(
             field_value, reassign_field=reassign_field, field_name=field_name
         )
+
     return field_value

reflex/testing.py

@@ -65,6 +65,7 @@ if platform.system == "Windows":
 else:
     FRONTEND_POPEN_ARGS["start_new_session"] = True
 
+
 # borrowed from py3.11
 class chdir(contextlib.AbstractContextManager):
     """Non thread-safe context manager to change the current working directory."""
@@ -150,6 +151,7 @@ class AppHarness:
                 reflex.reflex.init(
                     name=self.app_name,
                     template=reflex.constants.Template.DEFAULT,
+                    loglevel=reflex.constants.LogLevel.INFO,
                 )
                 self.app_module_path.write_text(source_code)
         with chdir(self.app_path):
@@ -179,7 +181,7 @@ class AppHarness:
         frontend_env = os.environ.copy()
         frontend_env["PORT"] = "0"
         self.frontend_process = subprocess.Popen(
-            [reflex.utils.prerequisites.get_package_manager(), "run", "dev"],
+            [reflex.utils.prerequisites.get_install_package_manager(), "run", "dev"],
             stdout=subprocess.PIPE,
             encoding="utf-8",
             cwd=self.app_path / reflex.constants.WEB_DIR,