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

reflex/utils/build.py

@@ -9,12 +9,9 @@ import subprocess
 from pathlib import Path
 from typing import Optional, Union
 
-from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
-
 from reflex import constants
 from reflex.config import get_config
-from reflex.utils import console, path_ops, prerequisites
-from reflex.utils.processes import new_process
+from reflex.utils import console, path_ops, prerequisites, processes
 
 
 def update_json_file(file_path: str, update_dict: dict[str, Union[int, str]]):
@@ -39,7 +36,9 @@ def update_json_file(file_path: str, update_dict: dict[str, Union[int, str]]):
 
 def set_reflex_project_hash():
     """Write the hash of the Reflex project to a REFLEX_JSON."""
-    update_json_file(constants.REFLEX_JSON, {"project_hash": random.getrandbits(128)})
+    project_hash = random.getrandbits(128)
+    console.debug(f"Setting project hash to {project_hash}.")
+    update_json_file(constants.REFLEX_JSON, {"project_hash": project_hash})
 
 
 def set_environment_variables():
@@ -86,21 +85,19 @@ def generate_sitemap_config(deploy_url: str):
         f.write(templates.SITEMAP_CONFIG(config=config))
 
 
-def export_app(
+def export(
     backend: bool = True,
     frontend: bool = True,
     zip: bool = False,
     deploy_url: Optional[str] = None,
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
 ):
-    """Zip up the app for deployment.
+    """Export the app for deployment.
 
     Args:
         backend: Whether to zip up the backend app.
         frontend: Whether to zip up the frontend app.
         zip: Whether to zip the app.
         deploy_url: The URL of the deployed app.
-        loglevel: The log level to use.
     """
     # Remove the static folder.
     path_ops.rm(constants.WEB_STATIC_DIR)
@@ -111,13 +108,6 @@ def export_app(
         generate_sitemap_config(deploy_url)
         command = "export-sitemap"
 
-    # Create a progress object
-    progress = Progress(
-        *Progress.get_default_columns()[:-1],
-        MofNCompleteColumn(),
-        TimeElapsedColumn(),
-    )
-
     checkpoints = [
         "Linting and checking ",
         "Compiled successfully",
@@ -130,36 +120,12 @@ def export_app(
         "Export successful",
     ]
 
-    # Add a single task to the progress object
-    task = progress.add_task("Creating Production Build: ", total=len(checkpoints))
-
     # Start the subprocess with the progress bar.
-    try:
-        with progress, new_process(
-            [prerequisites.get_package_manager(), "run", command],
-            cwd=constants.WEB_DIR,
-        ) as export_process:
-            assert export_process.stdout is not None, "No stdout for export process."
-            for line in export_process.stdout:
-                if loglevel == constants.LogLevel.DEBUG:
-                    print(line, end="")
-
-                # Check for special strings and update the progress bar.
-                for special_string in checkpoints:
-                    if special_string in line:
-                        if special_string == "Export successful":
-                            progress.update(task, completed=len(checkpoints))
-                            break  # Exit the loop if the completion message is found
-                        else:
-                            progress.update(task, advance=1)
-                            break
-
-    except Exception as e:
-        console.print(f"[red]Export process errored: {e}")
-        console.print(
-            "[red]Run in with [bold]--loglevel debug[/bold] to see the full error."
-        )
-        os._exit(1)
+    process = processes.new_process(
+        [prerequisites.get_package_manager(), "run", command],
+        cwd=constants.WEB_DIR,
+    )
+    processes.show_progress("Creating Production Build", process, checkpoints)
 
     # Zip up the app.
     if zip:
@@ -203,24 +169,16 @@ def posix_export(backend: bool = True, frontend: bool = True):
 
 def setup_frontend(
     root: Path,
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
     disable_telemetry: bool = True,
 ):
-    """Set up the frontend.
+    """Set up the frontend to run the app.
 
     Args:
         root: The root path of the project.
-        loglevel: The log level to use.
         disable_telemetry: Whether to disable the Next telemetry.
     """
-    # Validate bun version.
-    prerequisites.validate_and_install_bun(initialize=False)
-
-    # Initialize the web directory if it doesn't exist.
-    web_dir = prerequisites.create_web_directory(root)
-
     # Install frontend packages.
-    prerequisites.install_frontend_packages(web_dir)
+    prerequisites.install_frontend_packages()
 
     # Copy asset files to public folder.
     path_ops.cp(
@@ -228,12 +186,12 @@ def setup_frontend(
         dest=str(root / constants.WEB_ASSETS_DIR),
     )
 
-    # set the environment variables in client(env.json)
+    # Set the environment variables in client (env.json).
     set_environment_variables()
 
     # Disable the Next telemetry.
     if disable_telemetry:
-        new_process(
+        processes.new_process(
             [
                 prerequisites.get_package_manager(),
                 "run",
@@ -248,15 +206,13 @@ def setup_frontend(
 
 def setup_frontend_prod(
     root: Path,
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
     disable_telemetry: bool = True,
 ):
     """Set up the frontend for prod mode.
 
     Args:
         root: The root path of the project.
-        loglevel: The log level to use.
         disable_telemetry: Whether to disable the Next telemetry.
     """
-    setup_frontend(root, loglevel, disable_telemetry)
-    export_app(loglevel=loglevel, deploy_url=get_config().deploy_url)
+    setup_frontend(root, disable_telemetry)
+    export(deploy_url=get_config().deploy_url)

reflex/utils/console.py

@@ -5,47 +5,123 @@ from __future__ import annotations
 from typing import List, Optional
 
 from rich.console import Console
+from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 from rich.prompt import Prompt
-from rich.status import Status
+
+from reflex.constants import LogLevel
 
 # Console for pretty printing.
 _console = Console()
 
+# The current log level.
+LOG_LEVEL = LogLevel.INFO
 
-def deprecate(msg: str) -> None:
-    """Print a deprecation warning.
+
+def set_log_level(log_level: LogLevel):
+    """Set the log level.
 
     Args:
-        msg: The deprecation message.
+        log_level: The log level to set.
     """
-    _console.print(f"[yellow]DeprecationWarning: {msg}[/yellow]")
+    global LOG_LEVEL
+    LOG_LEVEL = log_level
 
 
-def log(msg: str) -> None:
-    """Takes a string and logs it to the console.
+def print(msg: str, **kwargs):
+    """Print a message.
 
     Args:
-        msg: The message to log.
+        msg: The message to print.
+        kwargs: Keyword arguments to pass to the print function.
     """
-    _console.log(msg)
+    _console.print(msg, **kwargs)
 
 
-def print(msg: str) -> None:
-    """Prints the given message to the console.
+def debug(msg: str, **kwargs):
+    """Print a debug message.
 
     Args:
-        msg: The message to print to the console.
+        msg: The debug message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.DEBUG:
+        print(f"[blue]Debug: {msg}[/blue]", **kwargs)
+
+
+def info(msg: str, **kwargs):
+    """Print an info message.
+
+    Args:
+        msg: The info message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.INFO:
+        print(f"[cyan]Info: {msg}[/cyan]", **kwargs)
+
+
+def success(msg: str, **kwargs):
+    """Print a success message.
+
+    Args:
+        msg: The success message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.INFO:
+        print(f"[green]Success: {msg}[/green]", **kwargs)
+
+
+def log(msg: str, **kwargs):
+    """Takes a string and logs it to the console.
+
+    Args:
+        msg: The message to log.
+        kwargs: Keyword arguments to pass to the print function.
     """
-    _console.print(msg)
+    if LOG_LEVEL <= LogLevel.INFO:
+        _console.log(msg, **kwargs)
 
 
-def rule(title: str) -> None:
+def rule(title: str, **kwargs):
     """Prints a horizontal rule with a title.
 
     Args:
         title: The title of the rule.
+        kwargs: Keyword arguments to pass to the print function.
     """
-    _console.rule(title)
+    _console.rule(title, **kwargs)
+
+
+def warn(msg: str, **kwargs):
+    """Print a warning message.
+
+    Args:
+        msg: The warning message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.WARNING:
+        print(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
+
+
+def deprecate(msg: str, **kwargs):
+    """Print a deprecation warning.
+
+    Args:
+        msg: The deprecation message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.WARNING:
+        print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
+
+
+def error(msg: str, **kwargs):
+    """Print an error message.
+
+    Args:
+        msg: The error message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    if LOG_LEVEL <= LogLevel.ERROR:
+        print(f"[red]Error: {msg}[/red]", **kwargs)
 
 
 def ask(
@@ -60,19 +136,33 @@ def ask(
         default: The default option selected.
 
     Returns:
-        A string
+        A string with the user input.
     """
     return Prompt.ask(question, choices=choices, default=default)  # type: ignore
 
 
-def status(msg: str) -> Status:
-    """Returns a status,
-    which can be used as a context manager.
+def progress():
+    """Create a new progress bar.
+
+
+    Returns:
+        A new progress bar.
+    """
+    return Progress(
+        *Progress.get_default_columns()[:-1],
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    )
+
+
+def status(*args, **kwargs):
+    """Create a status with a spinner.
 
     Args:
-        msg: The message to be used as status title.
+        *args: Args to pass to the status.
+        **kwargs: Kwargs to pass to the status.
 
     Returns:
-        The status of the console.
+        A new status.
     """
-    return _console.status(msg)
+    return _console.status(*args, **kwargs)

reflex/utils/exec.py

@@ -3,16 +3,11 @@
 from __future__ import annotations
 
 import os
-import platform
-import subprocess
 from pathlib import Path
 
-from rich import print
-
 from reflex import constants
 from reflex.config import get_config
 from reflex.utils import console, prerequisites, processes
-from reflex.utils.processes import new_process
 from reflex.utils.watch import AssetFolderWatch
 
 
@@ -28,15 +23,13 @@ def start_watching_assets_folder(root):
 
 def run_process_and_launch_url(
     run_command: list[str],
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
 ):
     """Run the process and launch the URL.
 
     Args:
         run_command: The command to run.
-        loglevel: The log level to use.
     """
-    process = new_process(
+    process = processes.new_process(
         run_command,
         cwd=constants.WEB_DIR,
     )
@@ -45,22 +38,20 @@ def run_process_and_launch_url(
         for line in process.stdout:
             if "ready started server on" in line:
                 url = line.split("url: ")[-1].strip()
-                print(f"App running at: [bold green]{url}")
-            if loglevel == constants.LogLevel.DEBUG:
-                print(line, end="")
+                console.print(f"App running at: [bold green]{url}")
+            else:
+                console.debug(line)
 
 
 def run_frontend(
     root: Path,
     port: str,
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
 ):
     """Run the frontend.
 
     Args:
         root: The root path of the project.
         port: The port to run the frontend on.
-        loglevel: The log level to use.
     """
     # Start watching asset folder.
     start_watching_assets_folder(root)
@@ -68,31 +59,25 @@ def run_frontend(
     # Run the frontend in development mode.
     console.rule("[bold green]App Running")
     os.environ["PORT"] = get_config().frontend_port if port is None else port
-    run_process_and_launch_url(
-        [prerequisites.get_package_manager(), "run", "dev"], loglevel
-    )
+    run_process_and_launch_url([prerequisites.get_package_manager(), "run", "dev"])
 
 
 def run_frontend_prod(
     root: Path,
     port: str,
-    loglevel: constants.LogLevel = constants.LogLevel.ERROR,
 ):
     """Run the frontend.
 
     Args:
         root: The root path of the project (to keep same API as run_frontend).
         port: The port to run the frontend on.
-        loglevel: The log level to use.
     """
     # Set the port.
     os.environ["PORT"] = get_config().frontend_port if port is None else port
 
     # Run the frontend in production mode.
     console.rule("[bold green]App Running")
-    run_process_and_launch_url(
-        [prerequisites.get_package_manager(), "run", "prod"], loglevel
-    )
+    run_process_and_launch_url([constants.NPM_PATH, "run", "prod"])
 
 
 def run_backend(
@@ -109,25 +94,23 @@ def run_backend(
         port: The app port
         loglevel: The log level.
     """
-    cmd = [
-        "uvicorn",
-        f"{app_name}:{constants.APP_VAR}.{constants.API_VAR}",
-        "--host",
-        host,
-        "--port",
-        str(port),
-        "--log-level",
-        loglevel,
-        "--reload",
-        "--reload-dir",
-        app_name.split(".")[0],
-    ]
-    process = subprocess.Popen(cmd)
-
-    try:
-        process.wait()
-    except KeyboardInterrupt:
-        process.terminate()
+    processes.new_process(
+        [
+            "uvicorn",
+            f"{app_name}:{constants.APP_VAR}.{constants.API_VAR}",
+            "--host",
+            host,
+            "--port",
+            str(port),
+            "--log-level",
+            loglevel,
+            "--reload",
+            "--reload-dir",
+            app_name.split(".")[0],
+        ],
+        run=True,
+        show_logs=True,
+    )
 
 
 def run_backend_prod(
@@ -154,7 +137,7 @@ def run_backend_prod(
             str(port),
             f"{app_name}:{constants.APP_VAR}",
         ]
-        if platform.system() == "Windows"
+        if prerequisites.IS_WINDOWS
         else [
             *constants.RUN_BACKEND_PROD,
             "--bind",
@@ -171,4 +154,4 @@ def run_backend_prod(
         "--workers",
         str(num_workers),
     ]
-    subprocess.run(command)
+    processes.new_process(command, run=True, show_logs=True)

reflex/utils/format.py

@@ -6,6 +6,7 @@ import base64
 import io
 import json
 import os
+import os.path as op
 import re
 import sys
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type
@@ -460,6 +461,24 @@ def format_dict(prop: ComponentStyle) -> str:
     return fprop
 
 
+def format_breadcrumbs(route: str) -> list[tuple[str, str]]:
+    """Take a route and return a list of tuple for use in breadcrumb.
+
+    Args:
+        route: The route to transform.
+
+    Returns:
+        list[tuple[str, str]]: the list of tuples for the breadcrumb.
+    """
+    route_parts = route.lstrip("/").split("/")
+
+    # create and return breadcrumbs
+    return [
+        (part, op.join("/", *route_parts[: i + 1]))
+        for i, part in enumerate(route_parts)
+    ]
+
+
 def json_dumps(obj: Any) -> str:
     """Takes an object and returns a jsonified string.
 

reflex/utils/imports.py

@@ -9,7 +9,7 @@ ImportDict = Dict[str, Set[ImportVar]]
 
 
 def merge_imports(*imports) -> ImportDict:
-    """Merge two import dicts together.
+    """Merge multiple import dicts together.
 
     Args:
         *imports: The list of import dicts to merge.