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

reflex/constants/installer.py

@@ -1,46 +1,22 @@
-"""File for constants related to the installation process. (Bun/FNM/Node)."""
+"""File for constants related to the installation process. (Bun/Node)."""
 
 from __future__ import annotations
 
-import platform
-from pathlib import Path
 from types import SimpleNamespace
 
 from .base import IS_WINDOWS
 from .utils import classproperty
 
 
-def get_fnm_name() -> str | None:
-    """Get the appropriate fnm executable name based on the current platform.
-
-    Returns:
-            The fnm executable name for the current platform.
-    """
-    platform_os = platform.system()
-
-    if platform_os == "Windows":
-        return "fnm-windows"
-    elif platform_os == "Darwin":
-        return "fnm-macos"
-    elif platform_os == "Linux":
-        machine = platform.machine()
-        if machine == "arm" or machine.startswith("armv7"):
-            return "fnm-arm32"
-        elif machine.startswith("aarch") or machine.startswith("armv8"):
-            return "fnm-arm64"
-        return "fnm-linux"
-    return None
-
-
 # Bun config.
 class Bun(SimpleNamespace):
     """Bun constants."""
 
     # The Bun version.
-    VERSION = "1.2.0"
+    VERSION = "1.2.4"
 
     # Min Bun Version
-    MIN_VERSION = "1.1.0"
+    MIN_VERSION = "1.2.4"
 
     # URL to bun install script.
     INSTALL_URL = "https://raw.githubusercontent.com/reflex-dev/reflex/main/scripts/bun_install.sh"
@@ -81,43 +57,6 @@ registry = "{registry}"
 """
 
 
-# FNM config.
-class Fnm(SimpleNamespace):
-    """FNM constants."""
-
-    # The FNM version.
-    VERSION = "1.35.1"
-
-    FILENAME = get_fnm_name()
-
-    # The URL to the fnm release binary
-    INSTALL_URL = (
-        f"https://github.com/Schniz/fnm/releases/download/v{VERSION}/{FILENAME}.zip"
-    )
-
-    @classproperty
-    @classmethod
-    def DIR(cls) -> Path:
-        """The directory to store fnm.
-
-        Returns:
-            The directory to store fnm.
-        """
-        from reflex.config import environment
-
-        return environment.REFLEX_DIR.get() / "fnm"
-
-    @classproperty
-    @classmethod
-    def EXE(cls):
-        """The fnm executable binary.
-
-        Returns:
-            The fnm executable binary.
-        """
-        return cls.DIR / ("fnm.exe" if IS_WINDOWS else "fnm")
-
-
 # Node / NPM config
 class Node(SimpleNamespace):
     """Node/ NPM constants."""
@@ -127,42 +66,6 @@ class Node(SimpleNamespace):
     # The minimum required node version.
     MIN_VERSION = "18.18.0"
 
-    @classproperty
-    @classmethod
-    def BIN_PATH(cls):
-        """The node bin path.
-
-        Returns:
-            The node bin path.
-        """
-        return (
-            Fnm.DIR
-            / "node-versions"
-            / f"v{cls.VERSION}"
-            / "installation"
-            / ("bin" if not IS_WINDOWS else "")
-        )
-
-    @classproperty
-    @classmethod
-    def PATH(cls):
-        """The default path where node is installed.
-
-        Returns:
-            The default path where node is installed.
-        """
-        return cls.BIN_PATH / ("node.exe" if IS_WINDOWS else "node")
-
-    @classproperty
-    @classmethod
-    def NPM_PATH(cls):
-        """The default path where npm is installed.
-
-        Returns:
-            The default path where npm is installed.
-        """
-        return cls.BIN_PATH / "npm"
-
 
 class PackageJson(SimpleNamespace):
     """Constants used to build the package.json file."""
@@ -179,11 +82,11 @@ class PackageJson(SimpleNamespace):
 
     DEPENDENCIES = {
         "@emotion/react": "11.14.0",
-        "axios": "1.7.9",
+        "axios": "1.8.3",
         "json5": "2.2.3",
-        "next": "15.1.7",
+        "next": "15.0.4",
         "next-sitemap": "4.2.3",
-        "next-themes": "0.4.4",
+        "next-themes": "0.4.6",
         "react": "19.0.0",
         "react-dom": "19.0.0",
         "react-focus-lock": "2.13.6",
@@ -191,8 +94,8 @@ class PackageJson(SimpleNamespace):
         "universal-cookie": "7.2.2",
     }
     DEV_DEPENDENCIES = {
-        "autoprefixer": "10.4.20",
-        "postcss": "8.5.1",
+        "autoprefixer": "10.4.21",
+        "postcss": "8.5.3",
         "postcss-import": "16.1.0",
     }
     OVERRIDES = {

reflex/custom_components/custom_components.py

@@ -826,12 +826,19 @@ def _collect_details_for_gallery():
     Raises:
         Exit: If pyproject.toml file is ill-formed or the request to the backend services fails.
     """
+    import reflex_cli.constants
     from reflex_cli.utils import hosting
 
     console.rule("[bold]Authentication with Reflex Services")
     console.print("First let's log in to Reflex backend services.")
     access_token, _ = hosting.authenticated_token()
 
+    if not access_token:
+        console.error(
+            "Unable to authenticate with Reflex backend services. Make sure you are logged in."
+        )
+        raise typer.Exit(code=1)
+
     console.rule("[bold]Custom Component Information")
     params = {}
     package_name = None
@@ -845,10 +852,8 @@ def _collect_details_for_gallery():
     console.print(f"[ Custom component package name ] : {package_name}")
     params["package_name"] = package_name
 
-    config = get_config()
-
     post_custom_components_gallery_endpoint = (
-        f"{config.cp_backend_url}/custom-components/gallery"
+        f"{reflex_cli.constants.Hosting.HOSTING_SERVICE}/custom-components/gallery"
     )
 
     # Check the backend services if the user is allowed to update information of this package is already shared.

reflex/reflex.py

@@ -7,13 +7,14 @@ from pathlib import Path
 
 import typer
 import typer.core
-from reflex_cli.v2.deployments import check_version, hosting_cli
+from reflex_cli.v2.deployments import hosting_cli
 
 from reflex import constants
 from reflex.config import environment, get_config
 from reflex.custom_components.custom_components import custom_components_cli
 from reflex.state import reset_disk_state_manager
 from reflex.utils import console, redir, telemetry
+from reflex.utils.exec import should_use_granian
 
 # Disable typer+rich integration for help panels
 typer.core.rich = None  # pyright: ignore [reportPrivateImportUsage]
@@ -203,9 +204,19 @@ def _run(
 
     prerequisites.check_latest_package_version(constants.Reflex.MODULE_NAME)
 
-    if frontend:
-        # Get the app module.
-        prerequisites.get_compiled_app()
+    # Get the app module.
+    app_task = prerequisites.compile_app if frontend else prerequisites.validate_app
+
+    # Granian fails if the app is already imported.
+    if should_use_granian():
+        import concurrent.futures
+
+        compile_future = concurrent.futures.ProcessPoolExecutor(max_workers=1).submit(
+            app_task
+        )
+        compile_future.result()
+    else:
+        app_task()
 
     # Warn if schema is not up to date.
     prerequisites.check_schema_up_to_date()
@@ -386,6 +397,7 @@ def export(
 def login(loglevel: constants.LogLevel | None = typer.Option(None)):
     """Authenticate with experimental Reflex hosting service."""
     from reflex_cli.v2 import cli as hosting_cli
+    from reflex_cli.v2.deployments import check_version
 
     loglevel = loglevel or get_config().loglevel
 
@@ -407,6 +419,7 @@ def logout(
 ):
     """Log out of access to Reflex hosting service."""
     from reflex_cli.v2.cli import logout
+    from reflex_cli.v2.deployments import check_version
 
     check_version()
 
@@ -567,6 +580,7 @@ def deploy(
     from reflex_cli.constants.base import LogLevel as HostingLogLevel
     from reflex_cli.utils import dependency
     from reflex_cli.v2 import cli as hosting_cli
+    from reflex_cli.v2.deployments import check_version
 
     from reflex.utils import export as export_utils
     from reflex.utils import prerequisites

reflex/state.py

@@ -905,7 +905,14 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
         ]
         if len(parent_states) >= 2:
             raise ValueError(f"Only one parent state is allowed {parent_states}.")
-        return parent_states[0] if len(parent_states) == 1 else None
+        # The first non-mixin state in the mro is our parent.
+        for base in cls.mro()[1:]:
+            if base._mixin or not issubclass(base, BaseState):
+                continue
+            if base is BaseState:
+                break
+            return base
+        return None  # No known parent
 
     @classmethod
     @functools.lru_cache()
@@ -1664,6 +1671,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
 
         raise TypeError(
             f"Your handler {handler.fn.__qualname__} must only return/yield: None, Events or other EventHandlers referenced by their class (i.e. using `type(self)` or other class references)."
+            f" Returned events of types {', '.join(map(str, map(type, events)))!s}."
         )
 
     async def _as_state_update(

reflex/testing.py

@@ -371,7 +371,13 @@ class AppHarness:
 
         # Start the frontend.
         self.frontend_process = reflex.utils.processes.new_process(
-            [reflex.utils.prerequisites.get_package_manager(), "run", "dev"],
+            [
+                *reflex.utils.prerequisites.get_js_package_executor(raise_on_none=True)[
+                    0
+                ],
+                "run",
+                "dev",
+            ],
             cwd=self.app_path / reflex.utils.prerequisites.get_web_dir(),
             env={"PORT": "0"},
             **FRONTEND_POPEN_ARGS,

reflex/utils/build.py

@@ -212,7 +212,7 @@ def build(
 
     # Start the subprocess with the progress bar.
     process = processes.new_process(
-        [prerequisites.get_package_manager(), "run", command],
+        [*prerequisites.get_js_package_executor(raise_on_none=True)[0], "run", command],
         cwd=wdir,
         shell=constants.IS_WINDOWS,
     )
@@ -231,11 +231,10 @@ def setup_frontend(
     """
     # Create the assets dir if it doesn't exist.
     path_ops.mkdir(constants.Dirs.APP_ASSETS)
-
-    # Copy asset files to public folder.
     path_ops.cp(
         src=str(root / constants.Dirs.APP_ASSETS),
         dest=str(root / prerequisites.get_web_dir() / constants.Dirs.PUBLIC),
+        ignore=tuple(f"*.{ext}" for ext in constants.Reflex.STYLESHEETS_SUPPORTED),
     )
 
     # Set the environment variables in client (env.json).
@@ -248,7 +247,7 @@ def setup_frontend(
     if disable_telemetry:
         processes.new_process(
             [
-                prerequisites.get_package_manager(),
+                *prerequisites.get_js_package_executor(raise_on_none=True)[0],
                 "run",
                 "next",
                 "telemetry",

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,33 @@ 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():
+    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 +217,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
+    config = get_config()
 
-    app_module_path = Path(reflex.__file__).parent / "app_module_for_backend.py"
-
-    return (
-        f"{app_module_path!s}:{constants.CompileVars.APP}.{constants.CompileVars.API}"
-    )
+    return f"{config.module}:{constants.CompileVars.APP}"
 
 
 def run_backend(
@@ -313,7 +321,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,31 +340,37 @@ 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"`)'
-        )
-        os._exit(1)
+
+    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()
 
 
+@once
 def _get_backend_workers():
     from reflex.utils import processes
 
     config = get_config()
+
+    if config.gunicorn_workers is not None:
+        console.deprecate(
+            "config.gunicorn_workers",
+            reason="If you're using Granian, use GRANIAN_WORKERS instead.",
+            deprecation_version="0.7.4",
+            removal_version="0.8.0",
+        )
+
     return (
         processes.get_num_workers()
         if not config.gunicorn_workers
@@ -363,6 +378,51 @@ def _get_backend_workers():
     )
 
 
+@once
+def _get_backend_timeout():
+    config = get_config()
+
+    if config.timeout is not None:
+        console.deprecate(
+            "config.timeout",
+            reason="If you're using Granian, use GRANIAN_WORKERS_LIFETIME instead.",
+            deprecation_version="0.7.4",
+            removal_version="0.8.0",
+        )
+
+    return config.timeout
+
+
+@once
+def _get_backend_max_requests():
+    config = get_config()
+
+    if config.gunicorn_max_requests is not None:
+        console.deprecate(
+            "config.gunicorn_max_requests",
+            reason="",
+            deprecation_version="0.7.4",
+            removal_version="0.8.0",
+        )
+
+    return config.gunicorn_max_requests
+
+
+@once
+def _get_backend_max_requests_jitter():
+    config = get_config()
+
+    if config.gunicorn_max_requests_jitter is not None:
+        console.deprecate(
+            "config.gunicorn_max_requests_jitter",
+            reason="",
+            deprecation_version="0.7.4",
+            removal_version="0.8.0",
+        )
+
+    return config.gunicorn_max_requests_jitter
+
+
 def run_backend_prod(
     host: str,
     port: int,
@@ -404,17 +464,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 +490,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 +553,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 +598,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 +615,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')}")