reflex 0.7.14a6__py3-none-any.whl → 0.8.0a2__py3-none-any.whl

reflex/testing.py

@@ -241,7 +241,7 @@ class AppHarness:
     def _initialize_app(self):
         # disable telemetry reporting for tests
 
-        os.environ["TELEMETRY_ENABLED"] = "false"
+        os.environ["REFLEX_TELEMETRY_ENABLED"] = "false"
         CustomComponent.create().get_component.cache_clear()
         self.app_path.mkdir(parents=True, exist_ok=True)
         if self.app_source is not None:
@@ -344,8 +344,12 @@ class AppHarness:
         )
         self.backend.shutdown = self._get_backend_shutdown_handler()
         with chdir(self.app_path):
+            print(  # noqa: T201
+                "Creating backend in a new thread..."
+            )  # for pytest diagnosis
             self.backend_thread = threading.Thread(target=self.backend.run)
         self.backend_thread.start()
+        print("Backend started.")  # for pytest diagnosis #noqa: T201
 
     async def _reset_backend_state_manager(self):
         """Reset the StateManagerRedis event loop affinity.
@@ -377,11 +381,15 @@ class AppHarness:
         # Set up the frontend.
         with chdir(self.app_path):
             config = reflex.config.get_config()
+            print("Polling for servers...")  # for pytest diagnosis #noqa: T201
             config.api_url = "http://{}:{}".format(
-                *self._poll_for_servers().getsockname(),
+                *self._poll_for_servers(timeout=30).getsockname(),
             )
+            print("Building frontend...")  # for pytest diagnosis #noqa: T201
             reflex.utils.build.setup_frontend(self.app_path)
 
+        print("Frontend starting...")  # for pytest diagnosis #noqa: T201
+
         # Start the frontend.
         self.frontend_process = reflex.utils.processes.new_process(
             [
@@ -392,19 +400,20 @@ class AppHarness:
                 "dev",
             ],
             cwd=self.app_path / reflex.utils.prerequisites.get_web_dir(),
-            env={"PORT": "0"},
+            env={"PORT": "0", "NO_COLOR": "1"},
             **FRONTEND_POPEN_ARGS,
         )
 
     def _wait_frontend(self):
+        if self.frontend_process is None or self.frontend_process.stdout is None:
+            msg = "Frontend process has no stdout."
+            raise RuntimeError(msg)
         while self.frontend_url is None:
-            line = (
-                self.frontend_process.stdout.readline()  # pyright: ignore [reportOptionalMemberAccess]
-            )
+            line = self.frontend_process.stdout.readline()
             if not line:
                 break
             print(line)  # for pytest diagnosis #noqa: T201
-            m = re.search(reflex.constants.Next.FRONTEND_LISTENING_REGEX, line)
+            m = re.search(reflex.constants.ReactRouter.FRONTEND_LISTENING_REGEX, line)
             if m is not None:
                 self.frontend_url = m.group(1)
                 config = reflex.config.get_config()
@@ -840,6 +849,37 @@ class AppHarness:
             raise TimeoutError(msg)
         return state_manager.states
 
+    @staticmethod
+    def poll_for_result(
+        f: Callable[[], T],
+        exception: type[Exception] = Exception,
+        max_attempts: int = 5,
+        seconds_between_attempts: int = 1,
+    ) -> T:
+        """Poll for a result from a function.
+
+        Args:
+            f: function to call
+            exception: exception to catch
+            max_attempts: maximum number of attempts
+            seconds_between_attempts: seconds to wait between
+
+        Returns:
+            Result of the function
+
+        Raises:
+            AssertionError: if the function does not return a value
+        """
+        attempts = 0
+        while attempts < max_attempts:
+            try:
+                return f()
+            except exception:  # noqa: PERF203
+                attempts += 1
+                time.sleep(seconds_between_attempts)
+        msg = "Function did not return a value"
+        raise AssertionError(msg)
+
 
 class SimpleHTTPRequestHandlerCustomErrors(SimpleHTTPRequestHandler):
     """SimpleHTTPRequestHandler with custom error page handling."""
@@ -922,7 +962,7 @@ class Subdir404TCPServer(socketserver.TCPServer):
 class AppHarnessProd(AppHarness):
     """AppHarnessProd executes a reflex app in-process for testing.
 
-    In prod mode, instead of running `next dev` the app is exported as static
+    In prod mode, instead of running `react-router dev` the app is exported as static
     files and served via the builtin python http.server with custom 404 redirect
     handling. Additionally, the backend runs in multi-worker mode.
     """
@@ -937,7 +977,7 @@ class AppHarnessProd(AppHarness):
             / reflex.constants.Dirs.STATIC
         )
         error_page_map = {
-            404: web_root / "404.html",
+            404: web_root / "404" / "index.html",
         }
         with Subdir404TCPServer(
             ("", 0),
@@ -954,9 +994,11 @@ class AppHarnessProd(AppHarness):
         # Set up the frontend.
         with chdir(self.app_path):
             config = reflex.config.get_config()
+            print("Polling for servers...")  # for pytest diagnosis #noqa: T201
             config.api_url = "http://{}:{}".format(
-                *self._poll_for_servers().getsockname(),
+                *self._poll_for_servers(timeout=30).getsockname(),
             )
+            print("Building frontend...")  # for pytest diagnosis #noqa: T201
 
             get_config().loglevel = reflex.constants.LogLevel.INFO
 
@@ -973,6 +1015,8 @@ class AppHarnessProd(AppHarness):
                 env=reflex.constants.Env.PROD,
             )
 
+        print("Frontend starting...")  # for pytest diagnosis #noqa: T201
+
         self.frontend_thread = threading.Thread(target=self._run_frontend)
         self.frontend_thread.start()
 
@@ -996,8 +1040,12 @@ class AppHarnessProd(AppHarness):
             ),
         )
         self.backend.shutdown = self._get_backend_shutdown_handler()
+        print(  # noqa: T201
+            "Creating backend in a new thread..."
+        )
         self.backend_thread = threading.Thread(target=self.backend.run)
         self.backend_thread.start()
+        print("Backend started.")  # for pytest diagnosis #noqa: T201
 
     def _poll_for_servers(self, timeout: TimeoutType = None) -> socket.socket:
         try:

reflex/utils/build.py

@@ -2,16 +2,13 @@
 
 from __future__ import annotations
 
-import json
 import os
-import subprocess
 import zipfile
 from pathlib import Path
 
 from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 
 from reflex import constants
-from reflex.config import get_config
 from reflex.utils import console, path_ops, prerequisites, processes
 from reflex.utils.exec import is_in_app_harness
 
@@ -27,30 +24,6 @@ def set_env_json():
     )
 
 
-def generate_sitemap_config(deploy_url: str, export: bool = False):
-    """Generate the sitemap config file.
-
-    Args:
-        deploy_url: The URL of the deployed app.
-        export: If the sitemap are generated for an export.
-    """
-    # Import here to avoid circular imports.
-    from reflex.compiler import templates
-
-    config = {
-        "siteUrl": deploy_url,
-        "generateRobotsTxt": True,
-    }
-
-    if export:
-        config["outDir"] = constants.Dirs.STATIC
-
-    config = json.dumps(config)
-
-    sitemap = prerequisites.get_web_dir() / constants.Next.SITEMAP_CONFIG_FILE
-    sitemap.write_text(templates.SITEMAP_CONFIG(config=config))
-
-
 def _zip(
     component_name: constants.ComponentName,
     target: str | Path,
@@ -175,102 +148,85 @@ def zip_app(
         )
 
 
-def build(
-    deploy_url: str | None = None,
-    for_export: bool = False,
-):
-    """Build the app for deployment.
+def _duplicate_index_html_to_parent_dir(directory: Path):
+    """Duplicate index.html in the child directories to the given directory.
+
+    This makes accessing /route and /route/ work in production.
 
     Args:
-        deploy_url: The deployment URL.
-        for_export: Whether the build is for export.
+        directory: The directory to duplicate index.html to.
     """
+    for child in directory.iterdir():
+        if child.is_dir():
+            # If the child directory has an index.html, copy it to the parent directory.
+            index_html = child / "index.html"
+            if index_html.exists():
+                target = directory / (child.name + ".html")
+                if not target.exists():
+                    console.debug(f"Copying {index_html} to {target}")
+                    path_ops.cp(index_html, target)
+                else:
+                    console.debug(f"Skipping {index_html}, already exists at {target}")
+            # Recursively call this function for the child directory.
+            _duplicate_index_html_to_parent_dir(child)
+
+
+def build():
+    """Build the app for deployment."""
     wdir = prerequisites.get_web_dir()
 
     # Clean the static directory if it exists.
-    path_ops.rm(str(wdir / constants.Dirs.STATIC))
-
-    # The export command to run.
-    command = "export"
+    path_ops.rm(str(wdir / constants.Dirs.BUILD_DIR))
 
     checkpoints = [
-        "Linting and checking ",
-        "Creating an optimized production build",
-        "Route (pages)",
-        "prerendered as static HTML",
-        "Collecting page data",
-        "Finalizing page optimization",
-        "Collecting build traces",
+        "building for production",
+        "building SSR bundle for production",
+        "built in",
     ]
 
-    # Generate a sitemap if a deploy URL is provided.
-    if deploy_url is not None:
-        generate_sitemap_config(deploy_url, export=for_export)
-        command = "export-sitemap"
-
-        checkpoints.extend(["Loading next-sitemap", "Generation completed"])
-
     # Start the subprocess with the progress bar.
     process = processes.new_process(
-        [*prerequisites.get_js_package_executor(raise_on_none=True)[0], "run", command],
+        [
+            *prerequisites.get_js_package_executor(raise_on_none=True)[0],
+            "run",
+            "export",
+        ],
         cwd=wdir,
         shell=constants.IS_WINDOWS,
+        env={
+            **os.environ,
+            "NO_COLOR": "1",
+        },
     )
     processes.show_progress("Creating Production Build", process, checkpoints)
+    _duplicate_index_html_to_parent_dir(wdir / constants.Dirs.STATIC)
 
 
 def setup_frontend(
     root: Path,
-    disable_telemetry: bool = True,
 ):
     """Set up the frontend to run the app.
 
     Args:
         root: The root path of the project.
-        disable_telemetry: Whether to disable the Next telemetry.
     """
-    # Create the assets dir if it doesn't exist.
-    path_ops.mkdir(constants.Dirs.APP_ASSETS)
-    path_ops.copy_tree(
-        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).
     set_env_json()
 
     # update the last reflex run time.
     prerequisites.set_last_reflex_run_time()
 
-    # Disable the Next telemetry.
-    if disable_telemetry:
-        processes.new_process(
-            [
-                *prerequisites.get_js_package_executor(raise_on_none=True)[0],
-                "run",
-                "next",
-                "telemetry",
-                "disable",
-            ],
-            cwd=prerequisites.get_web_dir(),
-            stdout=subprocess.DEVNULL,
-            shell=constants.IS_WINDOWS,
-        )
-
 
 def setup_frontend_prod(
     root: Path,
-    disable_telemetry: bool = True,
 ):
     """Set up the frontend for prod mode.
 
     Args:
         root: The root path of the project.
-        disable_telemetry: Whether to disable the Next telemetry.
     """
-    setup_frontend(root, disable_telemetry)
-    build(deploy_url=get_config().deploy_url)
+    setup_frontend(root)
+    build()
 
 
 def _looks_like_venv_dir(dir_to_check: str | Path) -> bool:

reflex/utils/exec.py

@@ -12,7 +12,7 @@ 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
@@ -170,7 +170,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 +200,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)
@@ -367,21 +372,48 @@ def run_backend(
         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
 
-        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`
+        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
+
+            # go up a level to find dir without `__init__.py` or with `rxconfig.py`
             module_path = module_path.parent
 
         reload_paths = [module_path]
@@ -500,74 +532,6 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
     ).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
-
-
 def run_backend_prod(
     host: str,
     port: int,
@@ -601,72 +565,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 +595,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/imports.py

@@ -114,10 +114,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,7 +1,11 @@
 """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
 
 
@@ -23,3 +27,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