reflex 0.6.8a1__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

reflex/utils/exec.py

@@ -71,7 +71,9 @@ def notify_backend():
 # 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
-def run_process_and_launch_url(run_command: list[str], backend_present=True):
+def run_process_and_launch_url(
+    run_command: list[str | None], backend_present: bool = True
+):
     """Run the process and launch the URL.
 
     Args:
@@ -89,7 +91,7 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
         if process is None:
             kwargs = {}
             if constants.IS_WINDOWS and backend_present:
-                kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
+                kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # pyright: ignore [reportAttributeAccessIssue]
             process = processes.new_process(
                 run_command,
                 cwd=get_web_dir(),
@@ -134,7 +136,7 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
             break  # while True
 
 
-def run_frontend(root: Path, port: str, backend_present=True):
+def run_frontend(root: Path, port: str, backend_present: bool = True):
     """Run the frontend.
 
     Args:
@@ -151,12 +153,12 @@ def run_frontend(root: Path, port: str, backend_present=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"],  # type: ignore
+        [prerequisites.get_package_manager(), "run", "dev"],
         backend_present,
     )
 
 
-def run_frontend_prod(root: Path, port: str, backend_present=True):
+def run_frontend_prod(root: Path, port: str, backend_present: bool = True):
     """Run the frontend.
 
     Args:
@@ -173,7 +175,7 @@ def run_frontend_prod(root: Path, port: str, backend_present=True):
     # Run the frontend in production mode.
     console.rule("[bold green]App Running")
     run_process_and_launch_url(
-        [prerequisites.get_package_manager(), "run", "prod"],  # type: ignore
+        [prerequisites.get_package_manager(), "run", "prod"],
         backend_present,
     )
 
@@ -240,7 +242,32 @@ def run_backend(
         run_uvicorn_backend(host, port, loglevel)
 
 
-def run_uvicorn_backend(host, port, loglevel: LogLevel):
+def get_reload_dirs() -> list[Path]:
+    """Get the reload directories for the backend.
+
+    Returns:
+        The reload directories for the backend.
+    """
+    config = get_config()
+    reload_dirs = [Path(config.app_name)]
+    if config.app_module is not None and config.app_module.__file__:
+        module_path = Path(config.app_module.__file__).resolve().parent
+
+        while module_path.parent.name:
+            if any(
+                sibling_file.name == "__init__.py"
+                for sibling_file in module_path.parent.iterdir()
+            ):
+                # go up a level to find dir without `__init__.py`
+                module_path = module_path.parent
+            else:
+                break
+
+        reload_dirs = [module_path]
+    return reload_dirs
+
+
+def run_uvicorn_backend(host: str, port: int, loglevel: LogLevel):
     """Run the backend in development mode using Uvicorn.
 
     Args:
@@ -256,11 +283,11 @@ def run_uvicorn_backend(host, port, loglevel: LogLevel):
         port=port,
         log_level=loglevel.value,
         reload=True,
-        reload_dirs=[get_config().app_name],
+        reload_dirs=list(map(str, get_reload_dirs())),
     )
 
 
-def run_granian_backend(host, port, loglevel: LogLevel):
+def run_granian_backend(host: str, port: int, loglevel: LogLevel):
     """Run the backend in development mode using Granian.
 
     Args:
@@ -270,9 +297,11 @@ def run_granian_backend(host, port, loglevel: LogLevel):
     """
     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
+        from granian import Granian  # pyright: ignore [reportMissingImports]
+        from granian.constants import (  # pyright: ignore [reportMissingImports]
+            Interfaces,
+        )
+        from granian.log import LogLevels  # pyright: ignore [reportMissingImports]
 
         Granian(
             target=get_granian_target(),
@@ -281,8 +310,8 @@ def run_granian_backend(host, port, loglevel: LogLevel):
             interface=Interfaces.ASGI,
             log_level=LogLevels(loglevel.value),
             reload=True,
-            reload_paths=[Path(get_config().app_name)],
-            reload_ignore_dirs=[".web"],
+            reload_paths=get_reload_dirs(),
+            reload_ignore_dirs=[".web", ".states"],
         ).serve()
     except ImportError:
         console.error(
@@ -325,7 +354,7 @@ def run_backend_prod(
         run_uvicorn_backend_prod(host, port, loglevel)
 
 
-def run_uvicorn_backend_prod(host, port, loglevel):
+def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
     """Run the backend in production mode using Uvicorn.
 
     Args:
@@ -339,11 +368,11 @@ def run_uvicorn_backend_prod(host, port, loglevel):
 
     app_module = get_app_module()
 
-    RUN_BACKEND_PROD = f"gunicorn --worker-class {config.gunicorn_worker_class} --max-requests {config.gunicorn_max_requests} --max-requests-jitter {config.gunicorn_max_requests_jitter} --preload --timeout {config.timeout} --log-level critical".split()
-    RUN_BACKEND_PROD_WINDOWS = f"uvicorn --limit-max-requests {config.gunicorn_max_requests} --timeout-keep-alive {config.timeout}".split()
+    run_backend_prod = f"gunicorn --worker-class {config.gunicorn_worker_class} --max-requests {config.gunicorn_max_requests} --max-requests-jitter {config.gunicorn_max_requests_jitter} --preload --timeout {config.timeout} --log-level critical".split()
+    run_backend_prod_windows = f"uvicorn --limit-max-requests {config.gunicorn_max_requests} --timeout-keep-alive {config.timeout}".split()
     command = (
         [
-            *RUN_BACKEND_PROD_WINDOWS,
+            *run_backend_prod_windows,
             "--host",
             host,
             "--port",
@@ -352,7 +381,7 @@ def run_uvicorn_backend_prod(host, port, loglevel):
         ]
         if constants.IS_WINDOWS
         else [
-            *RUN_BACKEND_PROD,
+            *run_backend_prod,
             "--bind",
             f"{host}:{port}",
             "--threads",
@@ -377,7 +406,7 @@ def run_uvicorn_backend_prod(host, port, loglevel):
     )
 
 
-def run_granian_backend_prod(host, port, loglevel):
+def run_granian_backend_prod(host: str, port: int, loglevel: LogLevel):
     """Run the backend in production mode using Granian.
 
     Args:
@@ -388,7 +417,9 @@ def run_granian_backend_prod(host, port, loglevel):
     from reflex.utils import processes
 
     try:
-        from granian.constants import Interfaces  # type: ignore
+        from granian.constants import (  # pyright: ignore [reportMissingImports]
+            Interfaces,
+        )
 
         command = [
             "granian",
@@ -442,22 +473,22 @@ def output_system_info():
 
     system = platform.system()
 
+    fnm_info = f"[FNM {prerequisites.get_fnm_version()} (Expected: {constants.Fnm.VERSION}) (PATH: {constants.Fnm.EXE})]"
+
     if system != "Windows" or (
         system == "Windows" and prerequisites.is_windows_bun_supported()
     ):
         dependencies.extend(
             [
-                f"[FNM {prerequisites.get_fnm_version()} (Expected: {constants.Fnm.VERSION}) (PATH: {constants.Fnm.EXE})]",
-                f"[Bun {prerequisites.get_bun_version()} (Expected: {constants.Bun.VERSION}) (PATH: {config.bun_path})]",
+                fnm_info,
+                f"[Bun {prerequisites.get_bun_version()} (Expected: {constants.Bun.VERSION}) (PATH: {path_ops.get_bun_path()})]",
             ],
         )
     else:
-        dependencies.append(
-            f"[FNM {prerequisites.get_fnm_version()} (Expected: {constants.Fnm.VERSION}) (PATH: {constants.Fnm.EXE})]",
-        )
+        dependencies.append(fnm_info)
 
     if system == "Linux":
-        import distro  # type: ignore
+        import distro  # pyright: ignore[reportMissingImports]
 
         os_version = distro.name(pretty=True)
     else:
@@ -469,11 +500,11 @@ 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)}"  # type: ignore
+        f"Using package installer at: {prerequisites.get_install_package_manager(on_failure_return_none=True)}"
     )
     console.debug(
         f"Using package executer at: {prerequisites.get_package_manager(on_failure_return_none=True)}"
-    )  # type: ignore
+    )
     if system != "Windows":
         console.debug(f"Unzip path: {path_ops.which('unzip')}")
 
@@ -487,56 +518,20 @@ def is_testing_env() -> bool:
     return constants.PYTEST_CURRENT_TEST in os.environ
 
 
-def is_prod_mode() -> bool:
-    """Check if the app is running in production mode.
+def is_in_app_harness() -> bool:
+    """Whether the app is running in the app harness.
 
     Returns:
-        True if the app is running in production mode or False if running in dev mode.
+        True if the app is running in the app harness.
     """
-    current_mode = environment.REFLEX_ENV_MODE.get()
-    return current_mode == constants.Env.PROD
+    return constants.APP_HARNESS_FLAG in os.environ
 
 
-def is_frontend_only() -> bool:
-    """Check if the app is running in frontend-only mode.
-
-    Returns:
-        True if the app is running in frontend-only mode.
-    """
-    console.deprecate(
-        "is_frontend_only() is deprecated and will be removed in a future release.",
-        reason="Use `environment.REFLEX_FRONTEND_ONLY.get()` instead.",
-        deprecation_version="0.6.5",
-        removal_version="0.7.0",
-    )
-    return environment.REFLEX_FRONTEND_ONLY.get()
-
-
-def is_backend_only() -> bool:
-    """Check if the app is running in backend-only mode.
-
-    Returns:
-        True if the app is running in backend-only mode.
-    """
-    console.deprecate(
-        "is_backend_only() is deprecated and will be removed in a future release.",
-        reason="Use `environment.REFLEX_BACKEND_ONLY.get()` instead.",
-        deprecation_version="0.6.5",
-        removal_version="0.7.0",
-    )
-    return environment.REFLEX_BACKEND_ONLY.get()
-
-
-def should_skip_compile() -> bool:
-    """Whether the app should skip compile.
+def is_prod_mode() -> bool:
+    """Check if the app is running in production mode.
 
     Returns:
-        True if the app should skip compile.
+        True if the app is running in production mode or False if running in dev mode.
     """
-    console.deprecate(
-        "should_skip_compile() is deprecated and will be removed in a future release.",
-        reason="Use `environment.REFLEX_SKIP_COMPILE.get()` instead.",
-        deprecation_version="0.6.5",
-        removal_version="0.7.0",
-    )
-    return environment.REFLEX_SKIP_COMPILE.get()
+    current_mode = environment.REFLEX_ENV_MODE.get()
+    return current_mode == constants.Env.PROD

reflex/utils/export.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Optional
 
 from reflex import constants
-from reflex.config import get_config
+from reflex.config import environment, get_config
 from reflex.utils import build, console, exec, prerequisites, telemetry
 
 config = get_config()
@@ -18,6 +18,7 @@ def export(
     upload_db_file: bool = False,
     api_url: Optional[str] = None,
     deploy_url: Optional[str] = None,
+    env: constants.Env = constants.Env.PROD,
     loglevel: constants.LogLevel = console._LOG_LEVEL,
 ):
     """Export the app to a zip file.
@@ -30,11 +31,15 @@ def export(
         upload_db_file: Whether to upload the database file. Defaults to False.
         api_url: The API URL to use. Defaults to None.
         deploy_url: The deploy URL to use. Defaults to None.
+        env: The environment to use. Defaults to constants.Env.PROD.
         loglevel: The log level to use. Defaults to console._LOG_LEVEL.
     """
     # Set the log level.
     console.set_log_level(loglevel)
 
+    # Set env mode in the environment
+    environment.REFLEX_ENV_MODE.set(env)
+
     # Override the config url values if provided.
     if api_url is not None:
         config.api_url = str(api_url)

reflex/utils/format.py

@@ -11,7 +11,6 @@ from typing import TYPE_CHECKING, Any, List, Optional, Union
 from reflex import constants
 from reflex.constants.state import FRONTEND_EVENT_STATE
 from reflex.utils import exceptions
-from reflex.utils.console import deprecate
 
 if TYPE_CHECKING:
     from reflex.components.component import ComponentStyle
@@ -221,7 +220,7 @@ def _escape_js_string(string: str) -> str:
     """
 
     # TODO: we may need to re-vist this logic after new Var API is implemented.
-    def escape_outside_segments(segment):
+    def escape_outside_segments(segment: str):
         """Escape backticks in segments outside of `${}`.
 
         Args:
@@ -284,7 +283,7 @@ def format_var(var: Var) -> str:
     return str(var)
 
 
-def format_route(route: str, format_case=True) -> str:
+def format_route(route: str, format_case: bool = True) -> str:
     """Format the given route.
 
     Args:
@@ -378,7 +377,7 @@ def format_prop(
 
         # For dictionaries, convert any properties to strings.
         elif isinstance(prop, dict):
-            prop = serializers.serialize_dict(prop)  # type: ignore
+            prop = serializers.serialize_dict(prop)  # pyright: ignore [reportAttributeAccessIssue]
 
         else:
             # Dump the prop as JSON.
@@ -502,37 +501,6 @@ if TYPE_CHECKING:
     from reflex.vars import Var
 
 
-def format_event_chain(
-    event_chain: EventChain | Var[EventChain],
-    event_arg: Var | None = None,
-) -> str:
-    """DEPRECATED: format an event chain as a javascript invocation.
-
-    Use str(rx.Var.create(event_chain)) instead.
-
-    Args:
-        event_chain: The event chain to format.
-        event_arg: this argument is ignored.
-
-    Returns:
-        Compiled javascript code to queue the given event chain on the frontend.
-    """
-    deprecate(
-        feature_name="format_event_chain",
-        reason="Use str(rx.Var.create(event_chain)) instead",
-        deprecation_version="0.6.0",
-        removal_version="0.7.0",
-    )
-
-    from reflex.vars import Var
-    from reflex.vars.function import ArgsFunctionOperation
-
-    result = Var.create(event_chain)
-    if isinstance(result, ArgsFunctionOperation):
-        result = result._return_expr
-    return str(result)
-
-
 def format_queue_events(
     events: EventType | None = None,
     args_spec: Optional[ArgsSpec] = None,
@@ -565,14 +533,14 @@ def format_queue_events(
     from reflex.vars import FunctionVar, Var
 
     if not events:
-        return Var("(() => null)").to(FunctionVar, EventChain)  # type: ignore
+        return Var("(() => null)").to(FunctionVar, EventChain)
 
     # If no spec is provided, the function will take no arguments.
     def _default_args_spec():
         return []
 
     # Construct the arguments that the function accepts.
-    sig = inspect.signature(args_spec or _default_args_spec)  # type: ignore
+    sig = inspect.signature(args_spec or _default_args_spec)
     if sig.parameters:
         arg_def = ",".join(f"_{p}" for p in sig.parameters)
         arg_def = f"({arg_def})"
@@ -589,7 +557,7 @@ def format_queue_events(
         if isinstance(spec, (EventHandler, EventSpec)):
             specs = [call_event_handler(spec, args_spec or _default_args_spec)]
         elif isinstance(spec, type(lambda: None)):
-            specs = call_event_fn(spec, args_spec or _default_args_spec)  # type: ignore
+            specs = call_event_fn(spec, args_spec or _default_args_spec)  # pyright: ignore [reportAssignmentType, reportArgumentType]
             if isinstance(specs, Var):
                 raise ValueError(
                     f"Invalid event spec: {specs}. Expected a list of EventSpecs."
@@ -601,7 +569,7 @@ def format_queue_events(
     return Var(
         f"{arg_def} => {{queueEvents([{','.join(payloads)}], {constants.CompileVars.SOCKET}); "
         f"processEvent({constants.CompileVars.SOCKET})}}",
-    ).to(FunctionVar, EventChain)  # type: ignore
+    ).to(FunctionVar, EventChain)
 
 
 def format_query_params(router_data: dict[str, Any]) -> dict[str, str]:

reflex/utils/imports.py

@@ -90,7 +90,7 @@ def collapse_imports(
     }
 
 
-@dataclasses.dataclass(order=True, frozen=True)
+@dataclasses.dataclass(frozen=True)
 class ImportVar:
     """An import var."""
 
@@ -122,7 +122,7 @@ class ImportVar:
         """
         if self.alias:
             return (
-                self.alias if self.is_default else " as ".join([self.tag, self.alias])  # type: ignore
+                self.alias if self.is_default else " as ".join([self.tag, self.alias])  # pyright: ignore [reportCallIssue,reportArgumentType]
             )
         else:
             return self.tag or ""

reflex/utils/lazy_loader.py

@@ -1,11 +1,17 @@
 """Module to implement lazy loading in reflex."""
 
+from __future__ import annotations
+
 import copy
 
 import lazy_loader as lazy
 
 
-def attach(package_name, submodules=None, submod_attrs=None):
+def attach(
+    package_name: str,
+    submodules: set | None = None,
+    submod_attrs: dict | None = None,
+):
     """Replaces a package's __getattr__, __dir__, and __all__ attributes using lazy.attach.
     The lazy loader __getattr__ doesn't support tuples as list values. We needed to add
     this functionality (tuples) in Reflex to support 'import as _' statements. This function

reflex/utils/path_ops.py

@@ -9,7 +9,7 @@ import shutil
 from pathlib import Path
 
 from reflex import constants
-from reflex.config import environment
+from reflex.config import environment, get_config
 
 # Shorthand for join.
 join = os.linesep.join
@@ -118,7 +118,7 @@ def ln(src: str | Path, dest: str | Path, overwrite: bool = False) -> bool:
     return True
 
 
-def which(program: str | Path) -> str | Path | None:
+def which(program: str | Path) -> Path | None:
     """Find the path to an executable.
 
     Args:
@@ -127,7 +127,8 @@ def which(program: str | Path) -> str | Path | None:
     Returns:
         The path to the executable.
     """
-    return shutil.which(str(program))
+    which_result = shutil.which(program)
+    return Path(which_result) if which_result else None
 
 
 def use_system_node() -> bool:
@@ -156,12 +157,12 @@ def get_node_bin_path() -> Path | None:
     """
     bin_path = Path(constants.Node.BIN_PATH)
     if not bin_path.exists():
-        str_path = which("node")
-        return Path(str_path).parent.resolve() if str_path else None
-    return bin_path.resolve()
+        path = which("node")
+        return path.parent.absolute() if path else None
+    return bin_path.absolute()
 
 
-def get_node_path() -> str | None:
+def get_node_path() -> Path | None:
     """Get the node binary path.
 
     Returns:
@@ -169,12 +170,11 @@ def get_node_path() -> str | None:
     """
     node_path = Path(constants.Node.PATH)
     if use_system_node() or not node_path.exists():
-        system_node_path = which("node")
-        return str(system_node_path) if system_node_path else None
-    return str(node_path)
+        node_path = which("node")
+    return node_path
 
 
-def get_npm_path() -> str | None:
+def get_npm_path() -> Path | None:
     """Get npm binary path.
 
     Returns:
@@ -182,9 +182,20 @@ def get_npm_path() -> str | None:
     """
     npm_path = Path(constants.Node.NPM_PATH)
     if use_system_node() or not npm_path.exists():
-        system_npm_path = which("npm")
-        return str(system_npm_path) if system_npm_path else None
-    return str(npm_path)
+        npm_path = which("npm")
+    return npm_path.absolute() if npm_path else None
+
+
+def get_bun_path() -> Path | None:
+    """Get bun binary path.
+
+    Returns:
+        The path to the bun binary file.
+    """
+    bun_path = get_config().bun_path
+    if use_system_bun() or not bun_path.exists():
+        bun_path = which("bun")
+    return bun_path.absolute() if bun_path else None
 
 
 def update_json_file(file_path: str | Path, update_dict: dict[str, int | str]):
@@ -196,6 +207,9 @@ def update_json_file(file_path: str | Path, update_dict: dict[str, int | str]):
     """
     fp = Path(file_path)
 
+    # Create the parent directory if it doesn't exist.
+    fp.parent.mkdir(parents=True, exist_ok=True)
+
     # Create the file if it doesn't exist.
     fp.touch(exist_ok=True)