reflex 0.7.14a5__py3-none-any.whl → 0.8.0__py3-none-any.whl

reflex/utils/exec.py

@@ -12,17 +12,16 @@ import subprocess
 import sys
 from collections.abc import Sequence
 from pathlib import Path
-from typing import NamedTuple, TypedDict
+from typing import Any, NamedTuple, TypedDict
 from urllib.parse import urljoin
 
-import psutil
-
 from reflex import constants
 from reflex.config import get_config
 from reflex.constants.base import LogLevel
 from reflex.environment import environment
 from reflex.utils import console, path_ops
 from reflex.utils.decorator import once
+from reflex.utils.misc import get_module_path
 from reflex.utils.prerequisites import get_web_dir
 
 # For uvicorn windows bug fix (#2335)
@@ -130,12 +129,16 @@ def get_different_packages(
 def kill(proc_pid: int):
     """Kills a process and all its child processes.
 
+    Requires the `psutil` library to be installed.
+
     Args:
-        proc_pid (int): The process ID of the process to be killed.
+        proc_pid: The process ID of the process to be killed.
 
     Example:
         >>> kill(1234)
     """
+    import psutil
+
     process = psutil.Process(proc_pid)
     for proc in process.children(recursive=True):
         proc.kill()
@@ -170,7 +173,12 @@ def run_process_and_launch_url(
 
     while True:
         if process is None:
-            kwargs = {}
+            kwargs: dict[str, Any] = {
+                "env": {
+                    **os.environ,
+                    "NO_COLOR": "1",
+                }
+            }
             if constants.IS_WINDOWS and backend_present:
                 kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # pyright: ignore [reportAttributeAccessIssue]
             process = processes.new_process(
@@ -195,7 +203,7 @@ def run_process_and_launch_url(
                         + format_change("Dev Dependencies", dev_dependencies_change)
                     )
 
-                match = re.search(constants.Next.FRONTEND_LISTENING_REGEX, line)
+                match = re.search(constants.ReactRouter.FRONTEND_LISTENING_REGEX, line)
                 if match:
                     if first_run:
                         url = match.group(1)
@@ -318,15 +326,12 @@ def get_app_file() -> Path:
     if current_working_dir not in sys.path:
         # Add the current working directory to sys.path
         sys.path.insert(0, current_working_dir)
-    module_spec = importlib.util.find_spec(get_app_module())
-    if module_spec is None:
-        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
+    app_module = get_app_module()
+    module_path = get_module_path(app_module)
+    if module_path is None:
+        msg = f"Module {app_module} not found. Make sure the module is installed."
         raise ImportError(msg)
-    file_name = module_spec.origin
-    if file_name is None:
-        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
-        raise ImportError(msg)
-    return Path(file_name).resolve()
+    return module_path
 
 
 def get_app_instance_from_file() -> str:
@@ -362,26 +367,58 @@ def run_backend(
 
     # Run the backend in development mode.
     if should_use_granian():
+        # We import reflex app because this lets granian cache the module
+        import reflex.app  # noqa: F401
+
         run_granian_backend(host, port, loglevel)
     else:
         run_uvicorn_backend(host, port, loglevel)
 
 
+def _has_child_file(directory: Path, file_name: str) -> bool:
+    """Check if a directory has a child file with the given name.
+
+    Args:
+        directory: The directory to check.
+        file_name: The name of the file to look for.
+
+    Returns:
+        True if the directory has a child file with the given name, False otherwise.
+    """
+    return any(child_file.name == file_name for child_file in directory.iterdir())
+
+
 def get_reload_paths() -> Sequence[Path]:
     """Get the reload paths for the backend.
 
     Returns:
         The reload paths for the backend.
+
+    Raises:
+        RuntimeError: If the `__init__.py` file is found in the app root directory.
     """
     config = get_config()
     reload_paths = [Path.cwd()]
-    if (spec := importlib.util.find_spec(config.module)) is not None and spec.origin:
-        module_path = Path(spec.origin).resolve().parent
+    app_module = config.module
+    module_path = get_module_path(app_module)
+    if module_path is not None:
+        module_path = module_path.parent
+
+        while module_path.parent.name and _has_child_file(module_path, "__init__.py"):
+            if _has_child_file(module_path, "rxconfig.py"):
+                init_file = module_path / "__init__.py"
+                init_file_content = init_file.read_text()
+                if init_file_content.strip():
+                    msg = "There should not be an `__init__.py` file in your app root directory"
+                    raise RuntimeError(msg)
+                console.warn(
+                    "Removing `__init__.py` file in the app root directory. "
+                    "This file can cause issues with module imports. "
+                )
+                init_file.unlink()
+                break
 
-        while module_path.parent.name and any(
-            sibling_file.name == "__init__.py" for sibling_file in module_path.iterdir()
-        ):
-            # go up a level to find dir without `__init__.py`
+            # go up a level to find dir without `__init__.py` or with `rxconfig.py`
             module_path = module_path.parent
 
         reload_paths = [module_path]
@@ -482,9 +519,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
 
     from granian.constants import Interfaces
     from granian.log import LogLevels
-    from granian.server import MPServer as Granian
+    from granian.server import Server as Granian
 
-    Granian(
+    from reflex.environment import _paths_from_environment
+
+    granian_app = Granian(
         target=get_app_instance_from_file(),
         factory=True,
         address=host,
@@ -496,76 +535,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
         reload_ignore_worker_failure=True,
         reload_ignore_patterns=HOTRELOAD_IGNORE_PATTERNS,
         reload_tick=100,
+        env_files=_paths_from_environment() or None,
         workers_kill_timeout=2,
-    ).serve()
-
-
-def _deprecate_asgi_config(
-    config_name: str,
-    reason: str = "",
-):
-    console.deprecate(
-        f"config.{config_name}",
-        reason=reason,
-        deprecation_version="0.7.9",
-        removal_version="0.8.0",
     )
 
-
-@once
-def _get_backend_workers():
-    from reflex.utils import processes
-
-    config = get_config()
-
-    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
+    granian_app.serve()
 
 
 def run_backend_prod(
@@ -601,72 +575,12 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
     """
     from reflex.utils import processes
 
-    config = get_config()
-
     app_module = get_app_instance()
 
     command = (
-        [
-            "uvicorn",
-            *(
-                (
-                    "--limit-max-requests",
-                    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 ()
-            ),
-            *("--host", host),
-            *("--port", str(port)),
-            *("--workers", str(_get_backend_workers())),
-            "--factory",
-            app_module,
-        ]
+        ["uvicorn", *("--host", host), *("--port", str(port)), "--factory", app_module]
         if constants.IS_WINDOWS
-        else [
-            "gunicorn",
-            *("--worker-class", config.gunicorn_worker_class),
-            *(
-                (
-                    "--max-requests",
-                    str(max_requessts),
-                )
-                if (
-                    (max_requessts := _get_backend_max_requests()) is not None
-                    and max_requessts > 0
-                )
-                else ()
-            ),
-            *(
-                (
-                    "--max-requests-jitter",
-                    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(timeout))
-                if (timeout := _get_backend_timeout()) is not None
-                else ()
-            ),
-            *("--bind", f"{host}:{port}"),
-            *("--threads", str(_get_backend_workers())),
-            f"{app_module}()",
-        ]
+        else ["gunicorn", "--preload", *("--bind", f"{host}:{port}"), f"{app_module}()"]
     )
 
     command += [
@@ -691,32 +605,26 @@ def run_granian_backend_prod(host: str, port: int, loglevel: LogLevel):
         port: The app port
         loglevel: The log level.
     """
+    from granian.constants import Interfaces
+
     from reflex.utils import processes
 
-    try:
-        from granian.constants import Interfaces
-
-        command = [
-            "granian",
-            *("--workers", str(_get_backend_workers())),
-            *("--log-level", "critical"),
-            *("--host", host),
-            *("--port", str(port)),
-            *("--interface", str(Interfaces.ASGI)),
-            *("--factory", get_app_instance_from_file()),
-        ]
-        processes.new_process(
-            command,
-            run=True,
-            show_logs=True,
-            env={
-                environment.REFLEX_SKIP_COMPILE.name: "true"
-            },  # skip compile for prod backend
-        )
-    except ImportError:
-        console.error(
-            'InstallError: REFLEX_USE_GRANIAN is set but `granian` is not installed. (run `pip install "granian[reload]>=1.6.0"`)'
-        )
+    command = [
+        "granian",
+        *("--log-level", "critical"),
+        *("--host", host),
+        *("--port", str(port)),
+        *("--interface", str(Interfaces.ASGI)),
+        *("--factory", get_app_instance_from_file()),
+    ]
+    processes.new_process(
+        command,
+        run=True,
+        show_logs=True,
+        env={
+            environment.REFLEX_SKIP_COMPILE.name: "true"
+        },  # skip compile for prod backend
+    )
 
 
 def output_system_info():

reflex/utils/export.py

@@ -56,13 +56,13 @@ def export(
 
     if frontend:
         # Ensure module can be imported and app.compile() is called.
-        prerequisites.get_compiled_app(export=True)
+        prerequisites.get_compiled_app(prerender_routes=True)
         # Set up .web directory and install frontend dependencies.
         build.setup_frontend(Path.cwd())
 
     # Build the static app.
     if frontend:
-        build.build(deploy_url=config.deploy_url, for_export=True)
+        build.build()
 
     # Zip up the app.
     if zipping:

reflex/utils/format.py

@@ -310,20 +310,16 @@ def format_var(var: Var) -> str:
     return str(var)
 
 
-def format_route(route: str, format_case: bool = True) -> str:
+def format_route(route: str) -> str:
     """Format the given route.
 
     Args:
         route: The route to format.
-        format_case: whether to format case to kebab case.
 
     Returns:
         The formatted route.
     """
     route = route.strip("/")
-    # Strip the route and format casing.
-    if format_case:
-        route = to_kebab_case(route)
 
     # If the route is empty, return the index route.
     if route == "":

reflex/utils/imports.py

@@ -52,19 +52,12 @@ def parse_imports(
     Returns:
         The parsed import dict.
     """
-
-    def _make_list(
-        value: ImmutableImportTypes,
-    ) -> list[str | ImportVar] | list[ImportVar]:
-        if isinstance(value, (str, ImportVar)):
-            return [value]
-        return list(value)
-
     return {
-        package: [
-            ImportVar(tag=tag) if isinstance(tag, str) else tag
-            for tag in _make_list(maybe_tags)
-        ]
+        package: [maybe_tags]
+        if isinstance(maybe_tags, ImportVar)
+        else [ImportVar(tag=maybe_tags)]
+        if isinstance(maybe_tags, str)
+        else [ImportVar(tag=tag) if isinstance(tag, str) else tag for tag in maybe_tags]
         for package, maybe_tags in imports.items()
     }
 
@@ -114,10 +107,6 @@ class ImportVar:
     # The path of the package to import from.
     package_path: str = "/"
 
-    # whether this import package should be added to transpilePackages in next.config.js
-    # https://nextjs.org/docs/app/api-reference/next-config-js/transpilePackages
-    transpile: bool | None = False
-
     @property
     def name(self) -> str:
         """The name of the import.

reflex/utils/misc.py

@@ -1,10 +1,53 @@
 """Miscellaneous functions for the experimental package."""
 
 import asyncio
+import contextlib
+import sys
+import threading
 from collections.abc import Callable
+from pathlib import Path
 from typing import Any
 
 
+def get_module_path(module_name: str) -> Path | None:
+    """Check if a module exists and return its path.
+
+    This function searches for a module by navigating through the module hierarchy
+    in each path of sys.path, checking for both .py files and packages with __init__.py.
+
+    Args:
+        module_name: The name of the module to search for (e.g., "package.submodule").
+
+    Returns:
+        The path to the module file if found, None otherwise.
+    """
+    parts = module_name.split(".")
+
+    # Check each path in sys.path
+    for path in sys.path:
+        current_path = Path(path)
+
+        # Navigate through the module hierarchy
+        for i, part in enumerate(parts):
+            potential_file = current_path / (part + ".py")
+            potential_dir = current_path / part
+
+            if potential_file.is_file():
+                # We encountered a file, but we can't continue deeper
+                if i == len(parts) - 1:
+                    return potential_file
+                return None  # Can't continue deeper
+            if potential_dir.is_dir():
+                # It's a package, so we can continue deeper
+                current_path = potential_dir
+            else:
+                break  # Path doesn't exist, break out of the loop
+        else:
+            return current_path / "__init__.py"  # Made it through all parts
+
+    return None
+
+
 async def run_in_thread(func: Callable) -> Any:
     """Run a function in a separate thread.
 
@@ -23,3 +66,27 @@ async def run_in_thread(func: Callable) -> Any:
         msg = "func must be a non-async function"
         raise ValueError(msg)
     return await asyncio.get_event_loop().run_in_executor(None, func)
+
+
+# Global lock for thread-safe sys.path manipulation
+_sys_path_lock = threading.RLock()
+
+
+@contextlib.contextmanager
+def with_cwd_in_syspath():
+    """Temporarily add current working directory to sys.path in a thread-safe manner.
+
+    This context manager temporarily prepends the current working directory to sys.path,
+    ensuring that modules in the current directory can be imported. The original sys.path
+    is restored when exiting the context.
+
+    Yields:
+        None
+    """
+    with _sys_path_lock:
+        orig_sys_path = sys.path.copy()
+        sys.path.insert(0, str(Path.cwd()))
+        try:
+            yield
+        finally:
+            sys.path[:] = orig_sys_path