reflex 0.6.0a3__py3-none-any.whl → 0.6.1__py3-none-any.whl

reflex/testing.py

@@ -340,6 +340,9 @@ class AppHarness:
 
         This is necessary when the backend is restarted and the state manager is a
         StateManagerRedis instance.
+
+        Raises:
+            RuntimeError: when the state manager cannot be reset
         """
         if (
             self.app_instance is not None
@@ -354,7 +357,8 @@ class AppHarness:
             self.app_instance._state_manager = StateManagerRedis.create(
                 state=self.app_instance.state,
             )
-            assert isinstance(self.app_instance.state_manager, StateManagerRedis)
+            if not isinstance(self.app_instance.state_manager, StateManagerRedis):
+                raise RuntimeError("Failed to reset state manager.")
 
     def _start_frontend(self):
         # Set up the frontend.
@@ -787,13 +791,13 @@ class AppHarness:
         Raises:
             RuntimeError: when the app hasn't started running
             TimeoutError: when the timeout expires before any states are seen
+            ValueError: when the state_manager is not a memory state manager
         """
         if self.app_instance is None:
             raise RuntimeError("App is not running.")
         state_manager = self.app_instance.state_manager
-        assert isinstance(
-            state_manager, (StateManagerMemory, StateManagerDisk)
-        ), "Only works with memory state manager"
+        if not isinstance(state_manager, (StateManagerMemory, StateManagerDisk)):
+            raise ValueError("Only works with memory or disk state manager")
         if not self._poll_for(
             target=lambda: state_manager.states,
             timeout=timeout,

reflex/utils/console.py

@@ -58,7 +58,7 @@ def debug(msg: str, **kwargs):
         kwargs: Keyword arguments to pass to the print function.
     """
     if is_debug():
-        msg_ = f"[blue]Debug: {msg}[/blue]"
+        msg_ = f"[purple]Debug: {msg}[/purple]"
         if progress := kwargs.pop("progress", None):
             progress.console.print(msg_, **kwargs)
         else:

reflex/utils/exceptions.py

@@ -111,3 +111,7 @@ class GeneratedCodeHasNoFunctionDefs(ReflexError):
 
 class PrimitiveUnserializableToJSON(ReflexError, ValueError):
     """Raised when a primitive type is unserializable to JSON. Usually with NaN and Infinity."""
+
+
+class InvalidLifespanTaskType(ReflexError, TypeError):
+    """Raised when an invalid task type is registered as a lifespan task."""

reflex/utils/exec.py

@@ -16,6 +16,7 @@ import psutil
 
 from reflex import constants
 from reflex.config import get_config
+from reflex.constants.base import LogLevel
 from reflex.utils import console, path_ops
 from reflex.utils.prerequisites import get_web_dir
 
@@ -60,6 +61,13 @@ def kill(proc_pid: int):
     process.kill()
 
 
+def notify_backend():
+    """Output a string notifying where the backend is running."""
+    console.print(
+        f"Backend running at: [bold green]http://0.0.0.0:{get_config().backend_port}[/bold green]"
+    )
+
+
 # run_process_and_launch_url is assumed to be used
 # only to launch the frontend
 # If this is not the case, might have to change the logic
@@ -103,9 +111,7 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
                             f"App running at: [bold green]{url}[/bold green]{' (Frontend-only mode)' if not backend_present else ''}"
                         )
                         if backend_present:
-                            console.print(
-                                f"Backend running at: [bold green]http://0.0.0.0:{get_config().backend_port}[/bold green]"
-                            )
+                            notify_backend()
                         first_run = False
                     else:
                         console.print("New packages detected: Updating app...")
@@ -172,10 +178,42 @@ def run_frontend_prod(root: Path, port: str, backend_present=True):
     )
 
 
+def should_use_granian():
+    """Whether to use Granian for backend.
+
+    Returns:
+        True if Granian should be used.
+    """
+    return os.getenv("REFLEX_USE_GRANIAN", "0") == "1"
+
+
+def get_app_module():
+    """Get the app module for the backend.
+
+    Returns:
+        The app module for the backend.
+    """
+    return f"reflex.app_module_for_backend:{constants.CompileVars.APP}"
+
+
+def get_granian_target():
+    """Get the Granian target for the backend.
+
+    Returns:
+        The Granian target for the backend.
+    """
+    import reflex
+
+    app_module_path = Path(reflex.__file__).parent / "app_module_for_backend.py"
+
+    return f"{str(app_module_path)}:{constants.CompileVars.APP}.{constants.CompileVars.API}"
+
+
 def run_backend(
     host: str,
     port: int,
     loglevel: constants.LogLevel = constants.LogLevel.ERROR,
+    frontend_present: bool = False,
 ):
     """Run the backend.
 
@@ -183,25 +221,82 @@ def run_backend(
         host: The app host
         port: The app port
         loglevel: The log level.
+        frontend_present: Whether the frontend is present.
     """
-    import uvicorn
-
-    config = get_config()
-    app_module = f"reflex.app_module_for_backend:{constants.CompileVars.APP}"
-
     web_dir = get_web_dir()
     # Create a .nocompile file to skip compile for backend.
     if web_dir.exists():
         (web_dir / constants.NOCOMPILE_FILE).touch()
 
+    if not frontend_present:
+        notify_backend()
+
     # Run the backend in development mode.
+    if should_use_granian():
+        run_granian_backend(host, port, loglevel)
+    else:
+        run_uvicorn_backend(host, port, loglevel)
+
+
+def run_uvicorn_backend(host, port, loglevel: LogLevel):
+    """Run the backend in development mode using Uvicorn.
+
+    Args:
+        host: The app host
+        port: The app port
+        loglevel: The log level.
+    """
+    import uvicorn
+
     uvicorn.run(
-        app=f"{app_module}.{constants.CompileVars.API}",
+        app=f"{get_app_module()}.{constants.CompileVars.API}",
         host=host,
         port=port,
         log_level=loglevel.value,
         reload=True,
-        reload_dirs=[config.app_name],
+        reload_dirs=[get_config().app_name],
+    )
+
+
+def run_granian_backend(host, port, loglevel: LogLevel):
+    """Run the backend in development mode using Granian.
+
+    Args:
+        host: The app host
+        port: The app port
+        loglevel: The log level.
+    """
+    console.debug("Using Granian for backend")
+    try:
+        from granian import Granian  # type: ignore
+        from granian.constants import Interfaces  # type: ignore
+        from granian.log import LogLevels  # type: ignore
+
+        Granian(
+            target=get_granian_target(),
+            address=host,
+            port=port,
+            interface=Interfaces.ASGI,
+            log_level=LogLevels(loglevel.value),
+            reload=True,
+            reload_paths=[Path(get_config().app_name)],
+            reload_ignore_dirs=[".web"],
+        ).serve()
+    except ImportError:
+        console.error(
+            'InstallError: REFLEX_USE_GRANIAN is set but `granian` is not installed. (run `pip install "granian>=1.6.0"`)'
+        )
+        os._exit(1)
+
+
+def _get_backend_workers():
+    from reflex.utils import processes
+
+    config = get_config()
+    return (
+        processes.get_num_workers()
+        if not config.gunicorn_workers
+        else config.gunicorn_workers
     )
 
 
@@ -209,9 +304,28 @@ def run_backend_prod(
     host: str,
     port: int,
     loglevel: constants.LogLevel = constants.LogLevel.ERROR,
+    frontend_present: bool = False,
 ):
     """Run the backend.
 
+    Args:
+        host: The app host
+        port: The app port
+        loglevel: The log level.
+        frontend_present: Whether the frontend is present.
+    """
+    if not frontend_present:
+        notify_backend()
+
+    if should_use_granian():
+        run_granian_backend_prod(host, port, loglevel)
+    else:
+        run_uvicorn_backend_prod(host, port, loglevel)
+
+
+def run_uvicorn_backend_prod(host, port, loglevel):
+    """Run the backend in production mode using Uvicorn.
+
     Args:
         host: The app host
         port: The app port
@@ -220,14 +334,11 @@ def run_backend_prod(
     from reflex.utils import processes
 
     config = get_config()
-    num_workers = (
-        processes.get_num_workers()
-        if not config.gunicorn_workers
-        else config.gunicorn_workers
-    )
+
+    app_module = get_app_module()
+
     RUN_BACKEND_PROD = f"gunicorn --worker-class {config.gunicorn_worker_class} --preload --timeout {config.timeout} --log-level critical".split()
     RUN_BACKEND_PROD_WINDOWS = f"uvicorn --timeout-keep-alive {config.timeout}".split()
-    app_module = f"reflex.app_module_for_backend:{constants.CompileVars.APP}"
     command = (
         [
             *RUN_BACKEND_PROD_WINDOWS,
@@ -243,7 +354,7 @@ def run_backend_prod(
             "--bind",
             f"{host}:{port}",
             "--threads",
-            str(num_workers),
+            str(_get_backend_workers()),
             f"{app_module}()",
         ]
     )
@@ -252,7 +363,7 @@ def run_backend_prod(
         "--log-level",
         loglevel.value,
         "--workers",
-        str(num_workers),
+        str(_get_backend_workers()),
     ]
     processes.new_process(
         command,
@@ -262,6 +373,47 @@ def run_backend_prod(
     )
 
 
+def run_granian_backend_prod(host, port, loglevel):
+    """Run the backend in production mode using Granian.
+
+    Args:
+        host: The app host
+        port: The app port
+        loglevel: The log level.
+    """
+    from reflex.utils import processes
+
+    try:
+        from granian.constants import Interfaces  # type: ignore
+
+        command = [
+            "granian",
+            "--workers",
+            str(_get_backend_workers()),
+            "--log-level",
+            "critical",
+            "--host",
+            host,
+            "--port",
+            str(port),
+            "--interface",
+            str(Interfaces.ASGI),
+            get_granian_target(),
+        ]
+        processes.new_process(
+            command,
+            run=True,
+            show_logs=True,
+            env={
+                constants.SKIP_COMPILE_ENV_VAR: "yes"
+            },  # skip compile for prod backend
+        )
+    except ImportError:
+        console.error(
+            'InstallError: REFLEX_USE_GRANIAN is set but `granian` is not installed. (run `pip install "granian>=1.6.0"`)'
+        )
+
+
 def output_system_info():
     """Show system information if the loglevel is in DEBUG."""
     if console._LOG_LEVEL > constants.LogLevel.DEBUG:

reflex/utils/format.py

@@ -9,7 +9,7 @@ import re
 from typing import TYPE_CHECKING, Any, Callable, List, Optional, Union
 
 from reflex import constants
-from reflex.utils import exceptions, types
+from reflex.utils import exceptions
 from reflex.utils.console import deprecate
 
 if TYPE_CHECKING:
@@ -345,6 +345,7 @@ def format_prop(
     Raises:
         exceptions.InvalidStylePropError: If the style prop value is not a valid type.
         TypeError: If the prop is not valid.
+        ValueError: If the prop is not a string.
     """
     # import here to avoid circular import.
     from reflex.event import EventChain
@@ -391,7 +392,8 @@ def format_prop(
         raise TypeError(f"Could not format prop: {prop} of type {type(prop)}") from e
 
     # Wrap the variable in braces.
-    assert isinstance(prop, str), "The prop must be a string."
+    if not isinstance(prop, str):
+        raise ValueError(f"Invalid prop: {prop}. Expected a string.")
     return wrap(prop, "{", check_first=False)
 
 
@@ -624,48 +626,6 @@ def format_query_params(router_data: dict[str, Any]) -> dict[str, str]:
     return {k.replace("-", "_"): v for k, v in params.items()}
 
 
-def format_state(value: Any, key: Optional[str] = None) -> Any:
-    """Recursively format values in the given state.
-
-    Args:
-        value: The state to format.
-        key: The key associated with the value (optional).
-
-    Returns:
-        The formatted state.
-
-    Raises:
-        TypeError: If the given value is not a valid state.
-    """
-    from reflex.utils import serializers
-
-    # Handle dicts.
-    if isinstance(value, dict):
-        return {k: format_state(v, k) for k, v in value.items()}
-
-    # Handle lists, sets, typles.
-    if isinstance(value, types.StateIterBases):
-        return [format_state(v) for v in value]
-
-    # Return state vars as is.
-    if isinstance(value, types.StateBases):
-        return value
-
-    # Serialize the value.
-    serialized = serializers.serialize(value)
-    if serialized is not None:
-        return serialized
-
-    if key is None:
-        raise TypeError(
-            f"No JSON serializer found for var {value} of type {type(value)}."
-        )
-    else:
-        raise TypeError(
-            f"No JSON serializer found for State Var '{key}' of value {value} of type {type(value)}."
-        )
-
-
 def format_state_name(state_name: str) -> str:
     """Format a state name, replacing dots with double underscore.
 
@@ -704,6 +664,8 @@ def format_library_name(library_fullname: str):
     Returns:
         The name without the @version if it was part of the name
     """
+    if library_fullname.startswith("https://"):
+        return library_fullname
     lib, at, version = library_fullname.rpartition("@")
     if not lib:
         lib = at + version

reflex/utils/path_ops.py

@@ -129,6 +129,41 @@ def which(program: str | Path) -> str | Path | None:
     return shutil.which(str(program))
 
 
+def use_system_install(var_name: str) -> bool:
+    """Check if the system install should be used.
+
+    Args:
+        var_name: The name of the environment variable.
+
+    Raises:
+        ValueError: If the variable name is invalid.
+
+    Returns:
+        Whether the associated env var should use the system install.
+    """
+    if not var_name.startswith("REFLEX_USE_SYSTEM_"):
+        raise ValueError("Invalid system install variable name.")
+    return os.getenv(var_name, "").lower() in ["true", "1", "yes"]
+
+
+def use_system_node() -> bool:
+    """Check if the system node should be used.
+
+    Returns:
+        Whether the system node should be used.
+    """
+    return use_system_install(constants.Node.USE_SYSTEM_VAR)
+
+
+def use_system_bun() -> bool:
+    """Check if the system bun should be used.
+
+    Returns:
+        Whether the system bun should be used.
+    """
+    return use_system_install(constants.Bun.USE_SYSTEM_VAR)
+
+
 def get_node_bin_path() -> str | None:
     """Get the node binary dir path.
 
@@ -149,7 +184,7 @@ def get_node_path() -> str | None:
         The path to the node binary file.
     """
     node_path = Path(constants.Node.PATH)
-    if not node_path.exists():
+    if use_system_node() or not node_path.exists():
         return str(which("node"))
     return str(node_path)
 

reflex/utils/prerequisites.py

@@ -16,7 +16,7 @@ import shutil
 import stat
 import sys
 import tempfile
-import textwrap
+import time
 import zipfile
 from datetime import datetime
 from fileinput import FileInput
@@ -36,6 +36,7 @@ from reflex import constants, model
 from reflex.compiler import templates
 from reflex.config import Config, get_config
 from reflex.utils import console, net, path_ops, processes
+from reflex.utils.exceptions import GeneratedCodeHasNoFunctionDefs
 from reflex.utils.format import format_library_name
 from reflex.utils.registry import _get_best_registry
 
@@ -73,6 +74,18 @@ def get_web_dir() -> Path:
     return workdir
 
 
+def _python_version_check():
+    """Emit deprecation warning for deprecated python versions."""
+    # Check for end-of-life python versions.
+    if sys.version_info < (3, 10):
+        console.deprecate(
+            feature_name="Support for Python 3.9 and older",
+            reason="please upgrade to Python 3.10 or newer",
+            deprecation_version="0.6.0",
+            removal_version="0.7.0",
+        )
+
+
 def check_latest_package_version(package_name: str):
     """Check if the latest version of the package is installed.
 
@@ -85,15 +98,16 @@ def check_latest_package_version(package_name: str):
         url = f"https://pypi.org/pypi/{package_name}/json"
         response = net.get(url)
         latest_version = response.json()["info"]["version"]
-        if (
-            version.parse(current_version) < version.parse(latest_version)
-            and not get_or_set_last_reflex_version_check_datetime()
-        ):
-            # only show a warning when the host version is outdated and
-            # the last_version_check_datetime is not set in reflex.json
+        if get_or_set_last_reflex_version_check_datetime():
+            # Versions were already checked and saved in reflex.json, no need to warn again
+            return
+        if version.parse(current_version) < version.parse(latest_version):
+            # Show a warning when the host version is older than PyPI version
             console.warn(
                 f"Your version ({current_version}) of {package_name} is out of date. Upgrade to {latest_version} with 'pip install {package_name} --upgrade'"
             )
+        # Check for depreacted python versions
+        _python_version_check()
     except Exception:
         pass
 
@@ -129,7 +143,7 @@ def check_node_version() -> bool:
         # Compare the version numbers
         return (
             current_version >= version.parse(constants.Node.MIN_VERSION)
-            if constants.IS_WINDOWS
+            if constants.IS_WINDOWS or path_ops.use_system_node()
             else current_version == version.parse(constants.Node.VERSION)
         )
     return False
@@ -290,7 +304,7 @@ def get_compiled_app(reload: bool = False, export: bool = False) -> ModuleType:
     """
     app_module = get_app(reload=reload)
     app = getattr(app_module, constants.CompileVars.APP)
-    # For py3.8 and py3.9 compatibility when redis is used, we MUST add any decorator pages
+    # For py3.9 compatibility when redis is used, we MUST add any decorator pages
     # before compiling the app in a thread to avoid event loop error (REF-2172).
     app._apply_decorated_pages()
     app._compile(export=export)
@@ -1020,6 +1034,8 @@ def validate_bun():
     # if a custom bun path is provided, make sure its valid
     # This is specific to non-FHS OS
     bun_path = get_config().bun_path
+    if path_ops.use_system_bun():
+        bun_path = path_ops.which("bun")
     if bun_path != constants.Bun.DEFAULT_PATH:
         console.info(f"Using custom Bun path: {bun_path}")
         bun_version = get_bun_version()
@@ -1442,19 +1458,37 @@ def initialize_main_module_index_from_generation(app_name: str, generation_hash:
     Args:
         app_name: The name of the app.
         generation_hash: The generation hash from reflex.build.
+
+    Raises:
+        GeneratedCodeHasNoFunctionDefs: If the fetched code has no function definitions
+            (the refactored reflex code is expected to have at least one root function defined).
     """
     # Download the reflex code for the generation.
-    resp = net.get(
-        constants.Templates.REFLEX_BUILD_CODE_URL.format(
-            generation_hash=generation_hash
+    url = constants.Templates.REFLEX_BUILD_CODE_URL.format(
+        generation_hash=generation_hash
+    )
+    resp = net.get(url)
+    while resp.status_code == httpx.codes.SERVICE_UNAVAILABLE:
+        console.debug("Waiting for the code to be generated...")
+        time.sleep(1)
+        resp = net.get(url)
+    resp.raise_for_status()
+
+    # Determine the name of the last function, which renders the generated code.
+    defined_funcs = re.findall(r"def ([a-zA-Z_]+)\(", resp.text)
+    if not defined_funcs:
+        raise GeneratedCodeHasNoFunctionDefs(
+            f"No function definitions found in generated code from {url!r}."
         )
-    ).raise_for_status()
+    render_func_name = defined_funcs[-1]
 
     def replace_content(_match):
         return "\n".join(
             [
-                "def index() -> rx.Component:",
-                textwrap.indent("return " + resp.text, "    "),
+                resp.text,
+                "",
+                "" "def index() -> rx.Component:",
+                f"    return {render_func_name}()",
                 "",
                 "",
             ],
@@ -1462,13 +1496,20 @@ def initialize_main_module_index_from_generation(app_name: str, generation_hash:
 
     main_module_path = Path(app_name, app_name + constants.Ext.PY)
     main_module_code = main_module_path.read_text()
-    main_module_path.write_text(
-        re.sub(
-            r"def index\(\).*:\n([^\n]\s+.*\n+)+",
-            replace_content,
-            main_module_code,
-        )
+
+    main_module_code = re.sub(
+        r"def index\(\).*:\n([^\n]\s+.*\n+)+",
+        replace_content,
+        main_module_code,
+    )
+    # Make the app use light mode until flexgen enforces the conversion of
+    # tailwind colors to radix colors.
+    main_module_code = re.sub(
+        r"app\s*=\s*rx\.App\(\s*\)",
+        'app = rx.App(theme=rx.theme(color_mode="light"))',
+        main_module_code,
     )
+    main_module_path.write_text(main_module_code)
 
 
 def format_address_width(address_width) -> int | None: