reflex 0.7.3a1__py3-none-any.whl → 0.7.4__py3-none-any.whl

reflex/utils/exec.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import hashlib
+import importlib.util
 import json
 import os
 import platform
@@ -19,6 +20,7 @@ from reflex import constants
 from reflex.config import environment, get_config
 from reflex.constants.base import LogLevel
 from reflex.utils import console, path_ops
+from reflex.utils.decorator import once
 from reflex.utils.prerequisites import get_web_dir
 
 # For uvicorn windows bug fix (#2335)
@@ -154,7 +156,11 @@ def run_frontend(root: Path, port: str, backend_present: bool = True):
     console.rule("[bold green]App Running")
     os.environ["PORT"] = str(get_config().frontend_port if port is None else port)
     run_process_and_launch_url(
-        [prerequisites.get_package_manager(), "run", "dev"],
+        [
+            *prerequisites.get_js_package_executor(raise_on_none=True)[0],
+            "run",
+            "dev",
+        ],
         backend_present,
     )
 
@@ -176,18 +182,35 @@ def run_frontend_prod(root: Path, port: str, backend_present: bool = True):
     # Run the frontend in production mode.
     console.rule("[bold green]App Running")
     run_process_and_launch_url(
-        [prerequisites.get_package_manager(), "run", "prod"],
+        [*prerequisites.get_js_package_executor(raise_on_none=True)[0], "run", "prod"],
         backend_present,
     )
 
 
+@once
+def _warn_user_about_uvicorn():
+    # When we eventually switch to Granian by default, we should enable this warning.
+    if False:
+        console.warn(
+            "Using Uvicorn for backend as it is installed. This behavior will change in 0.8.0 to use Granian by default."
+        )
+
+
 def should_use_granian():
     """Whether to use Granian for backend.
 
     Returns:
         True if Granian should be used.
     """
-    return environment.REFLEX_USE_GRANIAN.get()
+    if environment.REFLEX_USE_GRANIAN.get():
+        return True
+    if (
+        importlib.util.find_spec("uvicorn") is None
+        or importlib.util.find_spec("gunicorn") is None
+    ):
+        return True
+    _warn_user_about_uvicorn()
+    return False
 
 
 def get_app_module():
@@ -196,22 +219,9 @@ def get_app_module():
     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"
+    config = get_config()
 
-    return (
-        f"{app_module_path!s}:{constants.CompileVars.APP}.{constants.CompileVars.API}"
-    )
+    return f"{config.module}:{constants.CompileVars.APP}"
 
 
 def run_backend(
@@ -313,7 +323,8 @@ def run_uvicorn_backend(host: str, port: int, loglevel: LogLevel):
     import uvicorn
 
     uvicorn.run(
-        app=f"{get_app_module()}.{constants.CompileVars.API}",
+        app=f"{get_app_module()}",
+        factory=True,
         host=host,
         port=port,
         log_level=loglevel.value,
@@ -331,36 +342,91 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
         loglevel: The log level.
     """
     console.debug("Using Granian for backend")
-    try:
-        from granian.constants import Interfaces
-        from granian.log import LogLevels
-        from granian.server import Server as Granian
-
-        Granian(
-            target=get_granian_target(),
-            address=host,
-            port=port,
-            interface=Interfaces.ASGI,
-            log_level=LogLevels(loglevel.value),
-            reload=True,
-            reload_paths=get_reload_paths(),
-        ).serve()
-    except ImportError:
-        console.error(
-            'InstallError: REFLEX_USE_GRANIAN is set but `granian` is not installed. (run `pip install "granian[reload]>=1.6.0"`)'
+
+    from granian.constants import Interfaces
+    from granian.log import LogLevels
+    from granian.server import MPServer as Granian
+
+    Granian(
+        target=get_app_module(),
+        factory=True,
+        address=host,
+        port=port,
+        interface=Interfaces.ASGI,
+        log_level=LogLevels(loglevel.value),
+        reload=True,
+        reload_paths=get_reload_paths(),
+    ).serve()
+
+
+def _deprecate_asgi_config(
+    config_name: str,
+    reason: str = "",
+):
+    # When we eventually switch to Granian by default, we should enable this deprecation.
+    if False:
+        console.deprecate(
+            f"config.{config_name}",
+            reason=reason,
+            deprecation_version="0.7.5",
+            removal_version="0.8.0",
         )
-        os._exit(1)
 
 
+@once
 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
-    )
+
+    gunicorn_workers = config.gunicorn_workers or 0
+
+    if config.gunicorn_workers is not None:
+        _deprecate_asgi_config(
+            "gunicorn_workers",
+            "If you're using Granian, use GRANIAN_WORKERS instead.",
+        )
+
+    return gunicorn_workers if gunicorn_workers else processes.get_num_workers()
+
+
+@once
+def _get_backend_timeout():
+    config = get_config()
+
+    timeout = config.timeout or 120
+
+    if config.timeout is not None:
+        _deprecate_asgi_config(
+            "timeout",
+            "If you're using Granian, use GRANIAN_WORKERS_LIFETIME instead.",
+        )
+
+    return timeout
+
+
+@once
+def _get_backend_max_requests():
+    config = get_config()
+
+    gunicorn_max_requests = config.gunicorn_max_requests or 120
+
+    if config.gunicorn_max_requests is not None:
+        _deprecate_asgi_config("gunicorn_max_requests")
+
+    return gunicorn_max_requests
+
+
+@once
+def _get_backend_max_requests_jitter():
+    config = get_config()
+
+    gunicorn_max_requests_jitter = config.gunicorn_max_requests_jitter or 25
+
+    if config.gunicorn_max_requests_jitter is not None:
+        _deprecate_asgi_config("gunicorn_max_requests_jitter")
+
+    return gunicorn_max_requests_jitter
 
 
 def run_backend_prod(
@@ -404,17 +470,25 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
         [
             "uvicorn",
             *(
-                [
+                (
                     "--limit-max-requests",
-                    str(config.gunicorn_max_requests),
-                ]
-                if config.gunicorn_max_requests > 0
-                else []
+                    str(max_requessts),
+                )
+                if (
+                    (max_requessts := _get_backend_max_requests()) is not None
+                    and max_requessts > 0
+                )
+                else ()
+            ),
+            *(
+                ("--timeout-keep-alive", str(timeout))
+                if (timeout := _get_backend_timeout()) is not None
+                else ()
             ),
-            *("--timeout-keep-alive", str(config.timeout)),
             *("--host", host),
             *("--port", str(port)),
             *("--workers", str(_get_backend_workers())),
+            "--factory",
             app_module,
         ]
         if constants.IS_WINDOWS
@@ -422,17 +496,34 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
             "gunicorn",
             *("--worker-class", config.gunicorn_worker_class),
             *(
-                [
+                (
                     "--max-requests",
-                    str(config.gunicorn_max_requests),
+                    str(max_requessts),
+                )
+                if (
+                    (max_requessts := _get_backend_max_requests()) is not None
+                    and max_requessts > 0
+                )
+                else ()
+            ),
+            *(
+                (
                     "--max-requests-jitter",
-                    str(config.gunicorn_max_requests_jitter),
-                ]
-                if config.gunicorn_max_requests > 0
-                else []
+                    str(max_requessts_jitter),
+                )
+                if (
+                    (max_requessts_jitter := _get_backend_max_requests_jitter())
+                    is not None
+                    and max_requessts_jitter > 0
+                )
+                else ()
             ),
             "--preload",
-            *("--timeout", str(config.timeout)),
+            *(
+                ("--timeout", str(timeout))
+                if (timeout := _get_backend_timeout()) is not None
+                else ()
+            ),
             *("--bind", f"{host}:{port}"),
             *("--threads", str(_get_backend_workers())),
             f"{app_module}()",
@@ -468,17 +559,12 @@ def run_granian_backend_prod(host: str, port: int, loglevel: LogLevel):
 
         command = [
             "granian",
-            "--workers",
-            str(_get_backend_workers()),
-            "--log-level",
-            "critical",
-            "--host",
-            host,
-            "--port",
-            str(port),
-            "--interface",
-            str(Interfaces.ASGI),
-            get_granian_target(),
+            *("--workers", str(_get_backend_workers())),
+            *("--log-level", "critical"),
+            *("--host", host),
+            *("--port", str(port)),
+            *("--interface", str(Interfaces.ASGI)),
+            *("--factory", get_app_module()),
         ]
         processes.new_process(
             command,
@@ -518,13 +604,8 @@ def output_system_info():
 
     system = platform.system()
 
-    fnm_info = f"[FNM {prerequisites.get_fnm_version()} (Expected: {constants.Fnm.VERSION}) (PATH: {constants.Fnm.EXE})]"
-
-    dependencies.extend(
-        [
-            fnm_info,
-            f"[Bun {prerequisites.get_bun_version()} (Expected: {constants.Bun.VERSION}) (PATH: {path_ops.get_bun_path()})]",
-        ],
+    dependencies.append(
+        f"[Bun {prerequisites.get_bun_version()} (Expected: {constants.Bun.VERSION}) (PATH: {path_ops.get_bun_path()})]"
     )
 
     if system == "Linux":
@@ -540,10 +621,10 @@ def output_system_info():
         console.debug(f"{dep}")
 
     console.debug(
-        f"Using package installer at: {prerequisites.get_install_package_manager(on_failure_return_none=True)}"
+        f"Using package installer at: {prerequisites.get_nodejs_compatible_package_managers(raise_on_none=False)}"
     )
     console.debug(
-        f"Using package executer at: {prerequisites.get_package_manager(on_failure_return_none=True)}"
+        f"Using package executer at: {prerequisites.get_js_package_executor(raise_on_none=False)}"
     )
     if system != "Windows":
         console.debug(f"Unzip path: {path_ops.which('unzip')}")

reflex/utils/net.py

@@ -1,8 +1,13 @@
 """Helpers for downloading files from the network."""
 
+import functools
+import time
+from typing import Callable, ParamSpec, TypeVar
+
 import httpx
 
-from ..config import environment
+from reflex.utils.decorator import once
+
 from . import console
 
 
@@ -12,30 +17,114 @@ def _httpx_verify_kwarg() -> bool:
     Returns:
         True if SSL verification is enabled, False otherwise
     """
+    from ..config import environment
+
     return not environment.SSL_NO_VERIFY.get()
 
 
-def get(url: str, **kwargs) -> httpx.Response:
-    """Make an HTTP GET request.
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+def _wrap_https_func(
+    func: Callable[_P, _T],
+) -> Callable[_P, _T]:
+    """Wrap an HTTPS function with logging.
 
     Args:
-        url: The URL to request.
-        **kwargs: Additional keyword arguments to pass to httpx.get.
+        func: The function to wrap.
 
     Returns:
-        The response object.
+        The wrapped function.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+        url = args[0]
+        console.debug(f"Sending HTTPS request to {args[0]}")
+        initial_time = time.time()
+        try:
+            response = func(*args, **kwargs)
+        except httpx.ConnectError as err:
+            if "CERTIFICATE_VERIFY_FAILED" in str(err):
+                # If the error is a certificate verification error, recommend mitigating steps.
+                console.error(
+                    f"Certificate verification failed for {url}. Set environment variable SSL_CERT_FILE to the "
+                    "path of the certificate file or SSL_NO_VERIFY=1 to disable verification."
+                )
+            raise
+        else:
+            console.debug(
+                f"Received response from {url} in {time.time() - initial_time:.3f} seconds"
+            )
+            return response
+
+    return wrapper
+
 
-    Raises:
-        httpx.ConnectError: If the connection cannot be established.
+def _is_ipv4_supported() -> bool:
+    """Determine if the system supports IPv4.
+
+    Returns:
+        True if the system supports IPv4, False otherwise.
     """
-    kwargs.setdefault("verify", _httpx_verify_kwarg())
     try:
-        return httpx.get(url, **kwargs)
-    except httpx.ConnectError as err:
-        if "CERTIFICATE_VERIFY_FAILED" in str(err):
-            # If the error is a certificate verification error, recommend mitigating steps.
-            console.error(
-                f"Certificate verification failed for {url}. Set environment variable SSL_CERT_FILE to the "
-                "path of the certificate file or SSL_NO_VERIFY=1 to disable verification."
-            )
-        raise
+        httpx.head("http://1.1.1.1", timeout=3)
+    except httpx.RequestError:
+        return False
+    else:
+        return True
+
+
+def _is_ipv6_supported() -> bool:
+    """Determine if the system supports IPv6.
+
+    Returns:
+        True if the system supports IPv6, False otherwise.
+    """
+    try:
+        httpx.head("http://[2606:4700:4700::1111]", timeout=3)
+    except httpx.RequestError:
+        return False
+    else:
+        return True
+
+
+def _should_use_ipv6() -> bool:
+    """Determine if the system supports IPv6.
+
+    Returns:
+        True if the system supports IPv6, False otherwise.
+    """
+    return not _is_ipv4_supported() and _is_ipv6_supported()
+
+
+def _httpx_local_address_kwarg() -> str:
+    """Get the value of the HTTPX local_address keyword argument.
+
+    Returns:
+        The local address to bind to
+    """
+    from ..config import environment
+
+    return environment.REFLEX_HTTP_CLIENT_BIND_ADDRESS.get() or (
+        "::" if _should_use_ipv6() else "0.0.0.0"
+    )
+
+
+@once
+def _httpx_client() -> httpx.Client:
+    """Get an HTTPX client.
+
+    Returns:
+        An HTTPX client.
+    """
+    return httpx.Client(
+        transport=httpx.HTTPTransport(
+            local_address=_httpx_local_address_kwarg(),
+            verify=_httpx_verify_kwarg(),
+        )
+    )
+
+
+get = _wrap_https_func(_httpx_client().get)

reflex/utils/path_ops.py

@@ -9,7 +9,6 @@ import shutil
 import stat
 from pathlib import Path
 
-from reflex import constants
 from reflex.config import environment, get_config
 
 # Shorthand for join.
@@ -43,13 +42,19 @@ def rm(path: str | Path):
         path.unlink()
 
 
-def cp(src: str | Path, dest: str | Path, overwrite: bool = True) -> bool:
+def cp(
+    src: str | Path,
+    dest: str | Path,
+    overwrite: bool = True,
+    ignore: tuple[str, ...] | None = None,
+) -> bool:
     """Copy a file or directory.
 
     Args:
         src: The path to the file or directory.
         dest: The path to the destination.
         overwrite: Whether to overwrite the destination.
+        ignore: Ignoring files and directories that match one of the glob-style patterns provided
 
     Returns:
         Whether the copy was successful.
@@ -61,7 +66,11 @@ def cp(src: str | Path, dest: str | Path, overwrite: bool = True) -> bool:
         return False
     if src.is_dir():
         rm(dest)
-        shutil.copytree(src, dest)
+        shutil.copytree(
+            src,
+            dest,
+            ignore=shutil.ignore_patterns(*ignore) if ignore is not None else ignore,
+        )
     else:
         shutil.copyfile(src, dest)
     return True
@@ -146,15 +155,6 @@ def which(program: str | Path) -> Path | None:
     return Path(which_result) if which_result else None
 
 
-def use_system_node() -> bool:
-    """Check if the system node should be used.
-
-    Returns:
-        Whether the system node should be used.
-    """
-    return environment.REFLEX_USE_SYSTEM_NODE.get()
-
-
 def use_system_bun() -> bool:
     """Check if the system bun should be used.
 
@@ -170,11 +170,7 @@ def get_node_bin_path() -> Path | None:
     Returns:
         The path to the node bin folder.
     """
-    bin_path = Path(constants.Node.BIN_PATH)
-    if not bin_path.exists():
-        path = which("node")
-        return path.parent.absolute() if path else None
-    return bin_path.absolute()
+    return bin_path.parent.absolute() if (bin_path := get_node_path()) else None
 
 
 def get_node_path() -> Path | None:
@@ -183,10 +179,7 @@ def get_node_path() -> Path | None:
     Returns:
         The path to the node binary file.
     """
-    node_path = Path(constants.Node.PATH)
-    if use_system_node() or not node_path.exists():
-        node_path = which("node")
-    return node_path
+    return which("node")
 
 
 def get_npm_path() -> Path | None:
@@ -195,10 +188,7 @@ def get_npm_path() -> Path | None:
     Returns:
         The path to the npm binary file.
     """
-    npm_path = Path(constants.Node.NPM_PATH)
-    if use_system_node() or not npm_path.exists():
-        npm_path = which("npm")
-    return npm_path.absolute() if npm_path else None
+    return npm_path.absolute() if (npm_path := which("npm")) else None
 
 
 def get_bun_path() -> Path | None: