reflex 0.7.4a0__py3-none-any.whl → 0.7.4a2__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)
@@ -185,13 +187,30 @@ def run_frontend_prod(root: Path, port: str, backend_present: bool = True):
     )
 
 
+@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():
@@ -200,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(
@@ -317,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,
@@ -335,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(
@@ -408,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
@@ -426,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}()",
@@ -472,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,

reflex/utils/prerequisites.py

@@ -8,6 +8,7 @@ import functools
 import importlib
 import importlib.metadata
 import importlib.util
+import io
 import json
 import os
 import platform
@@ -183,7 +184,7 @@ def get_node_version() -> version.Version | None:
     try:
         result = processes.new_process([node_path, "-v"], run=True)
         # The output will be in the form "vX.Y.Z", but version.parse() can handle it
-        return version.parse(result.stdout)  # pyright: ignore [reportArgumentType]
+        return version.parse(result.stdout)
     except (FileNotFoundError, TypeError):
         return None
 
@@ -200,7 +201,7 @@ def get_bun_version() -> version.Version | None:
     try:
         # Run the bun -v command and capture the output
         result = processes.new_process([str(bun_path), "-v"], run=True)
-        return version.parse(str(result.stdout))  # pyright: ignore [reportArgumentType]
+        return version.parse(str(result.stdout))
     except FileNotFoundError:
         return None
     except version.InvalidVersion as e:
@@ -412,6 +413,15 @@ def get_and_validate_app(reload: bool = False) -> AppInfo:
     return AppInfo(app=app, module=app_module)
 
 
+def validate_app(reload: bool = False) -> None:
+    """Validate the app instance based on the default config.
+
+    Args:
+        reload: Re-import the app module from disk
+    """
+    get_and_validate_app(reload=reload)
+
+
 def get_compiled_app(reload: bool = False, export: bool = False) -> ModuleType:
     """Get the app module based on the default config after first compiling it.
 
@@ -430,6 +440,86 @@ def get_compiled_app(reload: bool = False, export: bool = False) -> ModuleType:
     return app_module
 
 
+def compile_app(reload: bool = False, export: bool = False) -> None:
+    """Compile the app module based on the default config.
+
+    Args:
+        reload: Re-import the app module from disk
+        export: Compile the app for export
+    """
+    get_compiled_app(reload=reload, export=export)
+
+
+def _can_colorize() -> bool:
+    """Check if the output can be colorized.
+
+    Copied from _colorize.can_colorize.
+
+    https://raw.githubusercontent.com/python/cpython/refs/heads/main/Lib/_colorize.py
+
+    Returns:
+        If the output can be colorized
+    """
+    file = sys.stdout
+
+    if not sys.flags.ignore_environment:
+        if os.environ.get("PYTHON_COLORS") == "0":
+            return False
+        if os.environ.get("PYTHON_COLORS") == "1":
+            return True
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("FORCE_COLOR"):
+        return True
+    if os.environ.get("TERM") == "dumb":
+        return False
+
+    if not hasattr(file, "fileno"):
+        return False
+
+    if sys.platform == "win32":
+        try:
+            import nt
+
+            if not nt._supports_virtual_terminal():
+                return False
+        except (ImportError, AttributeError):
+            return False
+
+    try:
+        return os.isatty(file.fileno())
+    except io.UnsupportedOperation:
+        return file.isatty()
+
+
+def compile_or_validate_app(compile: bool = False) -> bool:
+    """Compile or validate the app module based on the default config.
+
+    Args:
+        compile: Whether to compile the app.
+
+    Returns:
+        If the app is compiled successfully.
+    """
+    try:
+        if compile:
+            compile_app()
+        else:
+            validate_app()
+    except Exception as e:
+        import traceback
+
+        sys_exception = sys.exception()
+
+        try:
+            colorize = _can_colorize()
+            traceback.print_exception(e, colorize=colorize)  # pyright: ignore[reportCallIssue]
+        except Exception:
+            traceback.print_exception(sys_exception)
+        return False
+    return True
+
+
 def get_redis() -> Redis | None:
     """Get the asynchronous redis client.
 
@@ -1542,7 +1632,7 @@ def create_config_init_app_from_remote_template(app_name: str, template_url: str
         console.error(f"Failed to unzip the template: {uze}")
         raise typer.Exit(1) from uze
 
-    if len(subdirs := os.listdir(unzip_dir)) != 1:
+    if len(subdirs := list(unzip_dir.iterdir())) != 1:
         console.error(f"Expected one directory in the zip, found {subdirs}")
         raise typer.Exit(1)
 

reflex/utils/processes.py

@@ -10,7 +10,7 @@ import signal
 import subprocess
 from concurrent import futures
 from pathlib import Path
-from typing import Callable, Generator, Sequence, Tuple
+from typing import Any, Callable, Generator, Literal, Sequence, Tuple, overload
 
 import psutil
 import typer
@@ -142,12 +142,30 @@ def handle_port(service_name: str, port: int, auto_increment: bool) -> int:
         raise typer.Exit()
 
 
+@overload
+def new_process(
+    args: str | list[str] | list[str | None] | list[str | Path | None],
+    run: Literal[False] = False,
+    show_logs: bool = False,
+    **kwargs,
+) -> subprocess.Popen[str]: ...
+
+
+@overload
+def new_process(
+    args: str | list[str] | list[str | None] | list[str | Path | None],
+    run: Literal[True],
+    show_logs: bool = False,
+    **kwargs,
+) -> subprocess.CompletedProcess[str]: ...
+
+
 def new_process(
     args: str | list[str] | list[str | None] | list[str | Path | None],
     run: bool = False,
     show_logs: bool = False,
     **kwargs,
-):
+) -> subprocess.CompletedProcess[str] | subprocess.Popen[str]:
     """Wrapper over subprocess.Popen to unify the launch of child processes.
 
     Args:
@@ -163,7 +181,8 @@ def new_process(
         Exit: When attempting to run a command with a None value.
     """
     # Check for invalid command first.
-    if isinstance(args, list) and None in args:
+    non_empty_args = list(filter(None, args)) if isinstance(args, list) else [args]
+    if isinstance(args, list) and len(non_empty_args) != len(args):
         console.error(f"Invalid command: {args}")
         raise typer.Exit(1)
 
@@ -190,14 +209,20 @@ def new_process(
         "errors": "replace",  # Avoid UnicodeDecodeError in unknown command output
         **kwargs,
     }
-    console.debug(f"Running command: {args}")
-    fn = subprocess.run if run else subprocess.Popen
-    return fn(args, **kwargs)  # pyright: ignore [reportCallIssue, reportArgumentType]
+    console.debug(f"Running command: {non_empty_args}")
+
+    def subprocess_p_open(args: subprocess._CMD, **kwargs):
+        return subprocess.Popen(args, **kwargs)
+
+    fn: Callable[..., subprocess.CompletedProcess[str] | subprocess.Popen[str]] = (
+        subprocess.run if run else subprocess_p_open
+    )
+    return fn(non_empty_args, **kwargs)
 
 
 @contextlib.contextmanager
 def run_concurrently_context(
-    *fns: Callable | Tuple,
+    *fns: Callable[..., Any] | tuple[Callable[..., Any], ...],
 ) -> Generator[list[futures.Future], None, None]:
     """Run functions concurrently in a thread pool.
 
@@ -213,14 +238,14 @@ def run_concurrently_context(
         return
 
     # Convert the functions to tuples.
-    fns = [fn if isinstance(fn, tuple) else (fn,) for fn in fns]  # pyright: ignore [reportAssignmentType]
+    fns = tuple(fn if isinstance(fn, tuple) else (fn,) for fn in fns)
 
     # Run the functions concurrently.
     executor = None
     try:
         executor = futures.ThreadPoolExecutor(max_workers=len(fns))
         # Submit the tasks.
-        tasks = [executor.submit(*fn) for fn in fns]  # pyright: ignore [reportArgumentType]
+        tasks = [executor.submit(*fn) for fn in fns]
 
         # Yield control back to the main thread while tasks are running.
         yield tasks
@@ -311,6 +336,7 @@ def show_status(
     process: subprocess.Popen,
     suppress_errors: bool = False,
     analytics_enabled: bool = False,
+    prior_processes: Tuple[subprocess.Popen, ...] = (),
 ):
     """Show the status of a process.
 
@@ -319,15 +345,17 @@ def show_status(
         process: The process.
         suppress_errors: If True, do not exit if errors are encountered (for fallback).
         analytics_enabled: Whether analytics are enabled for this command.
+        prior_processes: The prior processes that have been run.
     """
-    with console.status(message) as status:
-        for line in stream_logs(
-            message,
-            process,
-            suppress_errors=suppress_errors,
-            analytics_enabled=analytics_enabled,
-        ):
-            status.update(f"{message} {line}")
+    for one_process in (*prior_processes, process):
+        with console.status(message) as status:
+            for line in stream_logs(
+                message,
+                one_process,
+                suppress_errors=suppress_errors,
+                analytics_enabled=analytics_enabled,
+            ):
+                status.update(f"{message} {line}")
 
 
 def show_progress(message: str, process: subprocess.Popen, checkpoints: list[str]):
@@ -381,6 +409,7 @@ def run_process_with_fallbacks(
     show_status_message: str,
     fallbacks: str | Sequence[str] | Sequence[Sequence[str]] | None = None,
     analytics_enabled: bool = False,
+    prior_processes: Tuple[subprocess.Popen, ...] = (),
     **kwargs,
 ):
     """Run subprocess and retry using fallback command if initial command fails.
@@ -390,7 +419,8 @@ def run_process_with_fallbacks(
         show_status_message: The status message to be displayed in the console.
         fallbacks: The fallback command to run if the initial command fails.
         analytics_enabled: Whether analytics are enabled for this command.
-        kwargs: Kwargs to pass to new_process function.
+        prior_processes: The prior processes that have been run.
+        **kwargs: Kwargs to pass to new_process function.
     """
     process = new_process(get_command_with_loglevel(args), **kwargs)
     if not fallbacks:
@@ -399,6 +429,7 @@ def run_process_with_fallbacks(
             show_status_message,
             process,
             analytics_enabled=analytics_enabled,
+            prior_processes=prior_processes,
         )
     else:
         # Suppress errors for initial command, because we will try to fallback
@@ -411,7 +442,7 @@ def run_process_with_fallbacks(
             # retry with fallback command.
             fallback_with_args = (
                 [current_fallback, *args[1:]]
-                if isinstance(fallbacks, str)
+                if isinstance(current_fallback, str)
                 else [*current_fallback, *args[1:]]
             )
             console.warn(
@@ -422,6 +453,7 @@ def run_process_with_fallbacks(
                 show_status_message=show_status_message,
                 fallbacks=next_fallbacks,
                 analytics_enabled=analytics_enabled,
+                prior_processes=(*prior_processes, process),
                 **kwargs,
             )
 

reflex/vars/base.py

@@ -160,7 +160,7 @@ class VarData:
         if isinstance(hooks, str):
             hooks = [hooks]
         if not isinstance(hooks, dict):
-            hooks = {hook: None for hook in (hooks or [])}
+            hooks = dict.fromkeys(hooks or [])
         immutable_imports: ImmutableParsedImportDict = tuple(
             (k, tuple(v)) for k, v in parse_imports(imports or {}).items()
         )
@@ -1791,8 +1791,7 @@ class cached_property:  # noqa: N801
                     if original_del is not None:
                         original_del(this)
                     return
-                if unique_id in GLOBAL_CACHE:
-                    del GLOBAL_CACHE[unique_id]
+                GLOBAL_CACHE.pop(unique_id, None)
 
                 if original_del is not None:
                     original_del(this)
@@ -3017,41 +3016,6 @@ _decode_var_pattern = re.compile(_decode_var_pattern_re, flags=re.DOTALL)
 _global_vars: dict[int, Var] = {}
 
 
-def _extract_var_data(value: Iterable) -> list[VarData | None]:
-    """Extract the var imports and hooks from an iterable containing a Var.
-
-    Args:
-        value: The iterable to extract the VarData from
-
-    Returns:
-        The extracted VarDatas.
-    """
-    from reflex.style import Style
-    from reflex.vars import Var
-
-    var_datas = []
-    with contextlib.suppress(TypeError):
-        for sub in value:
-            if isinstance(sub, Var):
-                var_datas.append(sub._var_data)
-            elif not isinstance(sub, str):
-                # Recurse into dict values.
-                if hasattr(sub, "values") and callable(sub.values):
-                    var_datas.extend(_extract_var_data(sub.values()))  # pyright: ignore [reportArgumentType]
-                # Recurse into iterable values (or dict keys).
-                var_datas.extend(_extract_var_data(sub))
-
-    # Style objects should already have _var_data.
-    if isinstance(value, Style):
-        var_datas.append(value._var_data)
-    else:
-        # Recurse when value is a dict itself.
-        values = getattr(value, "values", None)
-        if callable(values):
-            var_datas.extend(_extract_var_data(values()))  # pyright: ignore [reportArgumentType]
-    return var_datas
-
-
 dispatchers: dict[GenericType, Callable[[Var], Var]] = {}