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

reflex/utils/prerequisites.py

@@ -7,14 +7,15 @@ import json
 import os
 import platform
 import re
-import subprocess
 import sys
-from datetime import datetime
+import tempfile
+import threading
 from fileinput import FileInput
 from pathlib import Path
 from types import ModuleType
 from typing import Optional
 
+import httpx
 import typer
 from alembic.util.exc import CommandError
 from packaging import version
@@ -22,30 +23,32 @@ from redis import Redis
 
 from reflex import constants, model
 from reflex.config import get_config
-from reflex.utils import console, path_ops
+from reflex.utils import console, path_ops, processes
 
+IS_WINDOWS = platform.system() == "Windows"
 
-def check_node_version(min_version=constants.MIN_NODE_VERSION):
-    """Check the version of Node.js.
 
-    Args:
-        min_version: The minimum version of Node.js required.
+def check_node_version() -> bool:
+    """Check the version of Node.js.
 
     Returns:
-        Whether the version of Node.js is high enough.
+        Whether the version of Node.js is valid.
     """
     try:
-        # Run the node -v command and capture the output
-        result = subprocess.run(
-            ["node", "-v"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        # The output will be in the form "vX.Y.Z", but version.parse() can handle it
-        current_version = version.parse(result.stdout.decode())
-        # Compare the version numbers
-        return current_version >= version.parse(min_version)
-    except Exception:
+        # Run the node -v command and capture the output.
+        result = processes.new_process([constants.NODE_PATH, "-v"], run=True)
+    except FileNotFoundError:
         return False
 
+    # The output will be in the form "vX.Y.Z", but version.parse() can handle it
+    current_version = version.parse(result.stdout)  # type: ignore
+    # Compare the version numbers
+    return (
+        current_version >= version.parse(constants.NODE_VERSION_MIN)
+        if IS_WINDOWS
+        else current_version == version.parse(constants.NODE_VERSION)
+    )
+
 
 def get_bun_version() -> Optional[version.Version]:
     """Get the version of bun.
@@ -55,45 +58,56 @@ def get_bun_version() -> Optional[version.Version]:
     """
     try:
         # Run the bun -v command and capture the output
-        result = subprocess.run(
-            [os.path.expandvars(get_config().bun_path), "-v"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        return version.parse(result.stdout.decode().strip())
-    except Exception:
+        result = processes.new_process([constants.BUN_PATH, "-v"], run=True)
+        return version.parse(result.stdout)  # type: ignore
+    except FileNotFoundError:
         return None
 
 
-def get_package_manager() -> str:
-    """Get the package manager executable.
+def get_windows_package_manager() -> str:
+    """Get the package manager for windows.
 
     Returns:
-        The path to the package manager.
+        The path to the package manager for windows.
 
     Raises:
         FileNotFoundError: If bun or npm is not installed.
-        Exit: If the app directory is invalid.
-
     """
-    config = get_config()
+    npm_path = path_ops.which("npm")
+    if npm_path is None:
+        raise FileNotFoundError("Reflex requires npm to be installed on Windows.")
+    return npm_path
 
-    # Check that the node version is valid.
-    if not check_node_version():
-        console.print(
-            f"[red]Node.js version {constants.MIN_NODE_VERSION} or higher is required to run Reflex."
-        )
-        raise typer.Exit()
+
+def get_install_package_manager() -> str:
+    """Get the package manager executable for installation.
+      currently on unix systems, bun is used for installation only.
+
+    Returns:
+        The path to the package manager.
+    """
+    get_config()
 
     # On Windows, we use npm instead of bun.
-    if platform.system() == "Windows" or config.disable_bun:
-        npm_path = path_ops.which("npm")
-        if npm_path is None:
-            raise FileNotFoundError("Reflex requires npm to be installed on Windows.")
-        return npm_path
+    if IS_WINDOWS:
+        return get_windows_package_manager()
 
     # On other platforms, we use bun.
-    return os.path.expandvars(get_config().bun_path)
+    return constants.BUN_PATH
+
+
+def get_package_manager() -> str:
+    """Get the package manager executable for running app.
+      currently on unix systems, npm is used for running the app only.
+
+    Returns:
+        The path to the package manager.
+    """
+    get_config()
+
+    if IS_WINDOWS:
+        return get_windows_package_manager()
+    return constants.NPM_PATH
 
 
 def get_app() -> ModuleType:
@@ -118,7 +132,7 @@ def get_redis() -> Optional[Redis]:
     if config.redis_url is None:
         return None
     redis_url, redis_port = config.redis_url.split(":")
-    print("Using redis at", config.redis_url)
+    console.info(f"Using redis at {config.redis_url}")
     return Redis(host=redis_url, port=int(redis_port), db=0)
 
 
@@ -142,8 +156,20 @@ def get_default_app_name() -> str:
 
     Returns:
         The default app name.
+
+    Raises:
+        Exit: if the app directory name is reflex.
     """
-    return os.getcwd().split(os.path.sep)[-1].replace("-", "_")
+    app_name = os.getcwd().split(os.path.sep)[-1].replace("-", "_")
+
+    # Make sure the app is not named "reflex".
+    if app_name == constants.MODULE_NAME:
+        console.error(
+            f"The app directory cannot be named [bold]{constants.MODULE_NAME}[/bold]."
+        )
+        raise typer.Exit()
+
+    return app_name
 
 
 def create_config(app_name: str):
@@ -157,24 +183,10 @@ def create_config(app_name: str):
 
     config_name = f"{re.sub(r'[^a-zA-Z]', '', app_name).capitalize()}Config"
     with open(constants.CONFIG_FILE, "w") as f:
+        console.debug(f"Creating {constants.CONFIG_FILE}")
         f.write(templates.RXCONFIG.render(app_name=app_name, config_name=config_name))
 
 
-def create_web_directory(root: Path) -> str:
-    """Creates a web directory in the given root directory
-    and returns the path to the directory.
-
-    Args:
-        root (Path): The root directory of the project.
-
-    Returns:
-        The path to the web directory.
-    """
-    web_dir = str(root / constants.WEB_DIR)
-    path_ops.cp(constants.WEB_TEMPLATE_DIR, web_dir, overwrite=False)
-    return web_dir
-
-
 def initialize_gitignore():
     """Initialize the template .gitignore file."""
     # The files to add to the .gitignore file.
@@ -184,8 +196,10 @@ def initialize_gitignore():
     if os.path.exists(constants.GITIGNORE_FILE):
         with open(constants.GITIGNORE_FILE, "r") as f:
             files |= set([line.strip() for line in f.readlines()])
+
     # Write files to the .gitignore file.
     with open(constants.GITIGNORE_FILE, "w") as f:
+        console.debug(f"Creating {constants.GITIGNORE_FILE}")
         f.write(f"{(path_ops.join(sorted(files))).lstrip()}")
 
 
@@ -232,112 +246,175 @@ def initialize_web_directory():
         json.dump(reflex_json, f, ensure_ascii=False)
 
 
-def validate_and_install_bun(initialize=True):
-    """Check that bun version requirements are met. If they are not,
-    ask user whether to install required version.
-
-    Args:
-        initialize: whether this function is called on `reflex init` or `reflex run`.
-
-    Raises:
-        Exit: If the bun version is not supported.
+def initialize_bun():
+    """Check that bun requirements are met, and install if not."""
+    if IS_WINDOWS:
+        # Bun is not supported on Windows.
+        console.debug("Skipping bun installation on Windows.")
+        return
 
-    """
+    # Check the bun version.
     bun_version = get_bun_version()
-    if bun_version is not None and (
-        bun_version < version.parse(constants.MIN_BUN_VERSION)
-        or bun_version > version.parse(constants.MAX_BUN_VERSION)
-    ):
-        console.print(
-            f"""[red]Bun version {bun_version} is not supported by Reflex. Please change your to bun version to be between {constants.MIN_BUN_VERSION} and {constants.MAX_BUN_VERSION}."""
+    if bun_version != version.parse(constants.BUN_VERSION):
+        console.debug(
+            f"Current bun version ({bun_version}) does not match ({constants.BUN_VERSION})."
         )
-        action = console.ask(
-            "Enter 'yes' to install the latest supported bun version or 'no' to exit.",
-            choices=["yes", "no"],
-            default="no",
-        )
-
-        if action == "yes":
-            remove_existing_bun_installation()
-            install_bun()
-            return
-        else:
-            raise typer.Exit()
-
-    if initialize:
+        remove_existing_bun_installation()
         install_bun()
 
 
 def remove_existing_bun_installation():
     """Remove existing bun installation."""
-    package_manager = get_package_manager()
-    if os.path.exists(package_manager):
-        console.log("Removing bun...")
-        path_ops.rm(os.path.expandvars(constants.BUN_ROOT_PATH))
+    console.debug("Removing existing bun installation.")
+    if os.path.exists(constants.BUN_PATH):
+        path_ops.rm(constants.BUN_ROOT_PATH)
+
+
+def initialize_node():
+    """Validate nodejs have install or not."""
+    if not check_node_version():
+        install_node()
+
+
+def download_and_run(url: str, *args, show_status: bool = False, **env):
+    """Download and run a script.
+
+    Args:
+        url: The url of the script.
+        args: The arguments to pass to the script.
+        show_status: Whether to show the status of the script.
+        env: The environment variables to use.
+    """
+    # Download the script
+    console.debug(f"Downloading {url}")
+    response = httpx.get(url)
+    if response.status_code != httpx.codes.OK:
+        response.raise_for_status()
+
+    # Save the script to a temporary file.
+    script = tempfile.NamedTemporaryFile()
+    with open(script.name, "w") as f:
+        f.write(response.text)
+
+    # Run the script.
+    env = {**os.environ, **env}
+    process = processes.new_process(["bash", f.name, *args], env=env)
+    show = processes.show_status if show_status else processes.show_logs
+    show(f"Installing {url}", process)
+
+
+def install_node():
+    """Install nvm and nodejs for use by Reflex.
+       Independent of any existing system installations.
+
+    Raises:
+        Exit: if installation failed
+    """
+    # NVM is not supported on Windows.
+    if IS_WINDOWS:
+        console.error(
+            f"Node.js version {constants.NODE_VERSION} or higher is required to run Reflex."
+        )
+        raise typer.Exit()
+
+    # Create the nvm directory and install.
+    path_ops.mkdir(constants.NVM_DIR)
+    env = {**os.environ, "NVM_DIR": constants.NVM_DIR}
+    download_and_run(constants.NVM_INSTALL_URL, show_status=True, **env)
+
+    # Install node.
+    # We use bash -c as we need to source nvm.sh to use nvm.
+    process = processes.new_process(
+        [
+            "bash",
+            "-c",
+            f". {constants.NVM_DIR}/nvm.sh && nvm install {constants.NODE_VERSION}",
+        ],
+        env=env,
+    )
+    processes.show_status("", process)
 
 
 def install_bun():
     """Install bun onto the user's system.
 
     Raises:
-        FileNotFoundError: if unzip or curl packages are not found.
+        FileNotFoundError: If required packages are not found.
     """
     # Bun is not supported on Windows.
-    if platform.system() == "Windows":
-        console.log("Skipping bun installation on Windows.")
+    if IS_WINDOWS:
+        console.debug("Skipping bun installation on Windows.")
         return
 
-    # Only install if bun is not already installed.
-    if not os.path.exists(get_package_manager()):
-        console.log("Installing bun...")
-
-        # Check if curl is installed
-        curl_path = path_ops.which("curl")
-        if curl_path is None:
-            raise FileNotFoundError("Reflex requires curl to be installed.")
-
-        # Check if unzip is installed
-        unzip_path = path_ops.which("unzip")
-        if unzip_path is None:
-            raise FileNotFoundError("Reflex requires unzip to be installed.")
-
-        os.system(constants.INSTALL_BUN)
+    # Skip if bun is already installed.
+    if os.path.exists(constants.BUN_PATH):
+        console.debug("Skipping bun installation as it is already installed.")
+        return
 
+    #  if unzip is installed
+    unzip_path = path_ops.which("unzip")
+    if unzip_path is None:
+        raise FileNotFoundError("Reflex requires unzip to be installed.")
 
-def install_frontend_packages(web_dir: str):
-    """Installs the base and custom frontend packages
-    into the given web directory.
+    # Run the bun install script.
+    download_and_run(
+        constants.BUN_INSTALL_URL,
+        f"bun-v{constants.BUN_VERSION}",
+        BUN_INSTALL=constants.BUN_ROOT_PATH,
+    )
 
-    Args:
-        web_dir: The directory where the frontend code is located.
-    """
-    # Install the frontend packages.
-    console.rule("[bold]Installing frontend packages")
 
+def install_frontend_packages():
+    """Installs the base and custom frontend packages."""
     # Install the base packages.
-    subprocess.run(
-        [get_package_manager(), "install"],
-        cwd=web_dir,
-        stdout=subprocess.PIPE,
+    process = processes.new_process(
+        [get_install_package_manager(), "install", "--loglevel", "silly"],
+        cwd=constants.WEB_DIR,
     )
+    processes.show_status("Installing base frontend packages", process)
 
     # Install the app packages.
     packages = get_config().frontend_packages
     if len(packages) > 0:
-        subprocess.run(
-            [get_package_manager(), "add", *packages],
-            cwd=web_dir,
-            stdout=subprocess.PIPE,
+        process = processes.new_process(
+            [get_install_package_manager(), "add", *packages],
+            cwd=constants.WEB_DIR,
         )
+        processes.show_status("Installing custom frontend packages", process)
 
 
-def is_initialized() -> bool:
-    """Check whether the app is initialized.
+def check_initialized(frontend: bool = True):
+    """Check that the app is initialized.
 
-    Returns:
-        Whether the app is initialized in the current directory.
+    Args:
+        frontend: Whether to check if the frontend is initialized.
+
+    Raises:
+        Exit: If the app is not initialized.
     """
-    return os.path.exists(constants.CONFIG_FILE) and os.path.exists(constants.WEB_DIR)
+    has_config = os.path.exists(constants.CONFIG_FILE)
+    has_reflex_dir = IS_WINDOWS or os.path.exists(constants.REFLEX_DIR)
+    has_web_dir = not frontend or os.path.exists(constants.WEB_DIR)
+
+    # Check if the app is initialized.
+    if not (has_config and has_reflex_dir and has_web_dir):
+        console.error(
+            f"The app is not initialized. Run [bold]{constants.MODULE_NAME} init[/bold] first."
+        )
+        raise typer.Exit()
+
+    # Check that the template is up to date.
+    if frontend and not is_latest_template():
+        console.error(
+            "The base app template has updated. Run [bold]reflex init[/bold] again."
+        )
+        raise typer.Exit()
+
+    # Print a warning for Windows users.
+    if IS_WINDOWS:
+        console.warn(
+            "We strongly advise using Windows Subsystem for Linux (WSL) for optimal performance with reflex."
+        )
 
 
 def is_latest_template() -> bool:
@@ -353,20 +430,40 @@ def is_latest_template() -> bool:
     return app_version == constants.VERSION
 
 
+def initialize_frontend_dependencies():
+    """Initialize all the frontend dependencies."""
+    # Create the reflex directory.
+    path_ops.mkdir(constants.REFLEX_DIR)
+
+    # Install the frontend dependencies.
+    threads = [
+        threading.Thread(target=initialize_bun),
+        threading.Thread(target=initialize_node),
+    ]
+    for thread in threads:
+        thread.start()
+
+    # Set up the web directory.
+    initialize_web_directory()
+
+    # Wait for the threads to finish.
+    for thread in threads:
+        thread.join()
+
+
 def check_admin_settings():
     """Check if admin settings are set and valid for logging in cli app."""
     admin_dash = get_config().admin_dash
-    current_time = datetime.now()
     if admin_dash:
         if not admin_dash.models:
-            console.print(
-                f"[yellow][Admin Dashboard][/yellow] :megaphone: Admin dashboard enabled, but no models defined in [bold magenta]rxconfig.py[/bold magenta]. Time: {current_time}"
+            console.log(
+                f"[yellow][Admin Dashboard][/yellow] :megaphone: Admin dashboard enabled, but no models defined in [bold magenta]rxconfig.py[/bold magenta]."
             )
         else:
-            console.print(
-                f"[yellow][Admin Dashboard][/yellow] Admin enabled, building admin dashboard. Time: {current_time}"
+            console.log(
+                f"[yellow][Admin Dashboard][/yellow] Admin enabled, building admin dashboard."
             )
-            console.print(
+            console.log(
                 "Admin dashboard running at: [bold green]http://localhost:8000/admin[/bold green]"
             )
 
@@ -378,8 +475,8 @@ def check_db_initialized() -> bool:
         True if alembic is initialized (or if database is not used).
     """
     if get_config().db_url is not None and not Path(constants.ALEMBIC_CONFIG).exists():
-        console.print(
-            "[red]Database is not initialized. Run [bold]reflex db init[/bold] first."
+        console.error(
+            "Database is not initialized. Run [bold]reflex db init[/bold] first."
         )
         return False
     return True
@@ -395,14 +492,14 @@ def check_schema_up_to_date():
                 connection=connection,
                 write_migration_scripts=False,
             ):
-                console.print(
-                    "[red]Detected database schema changes. Run [bold]reflex db makemigrations[/bold] "
+                console.error(
+                    "Detected database schema changes. Run [bold]reflex db makemigrations[/bold] "
                     "to generate migration scripts.",
                 )
         except CommandError as command_error:
             if "Target database is not up to date." in str(command_error):
-                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."
                 )
 
 
@@ -421,7 +518,7 @@ def migrate_to_reflex():
         return
 
     # Rename pcconfig to rxconfig.
-    console.print(
+    console.log(
         f"[bold]Renaming {constants.OLD_CONFIG_FILE} to {constants.CONFIG_FILE}"
     )
     os.rename(constants.OLD_CONFIG_FILE, constants.CONFIG_FILE)