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

reflex/testing.py

@@ -22,9 +22,8 @@ import types
 from collections.abc import AsyncIterator, Callable, Coroutine, Sequence
 from http.server import SimpleHTTPRequestHandler
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
-import psutil
 import uvicorn
 
 import reflex
@@ -241,7 +240,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 +343,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 +380,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 +399,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()
@@ -469,6 +477,8 @@ class AppHarness:
 
     def stop(self) -> None:
         """Stop the frontend and backend servers."""
+        import psutil
+
         # Quit browsers first to avoid any lingering events being sent during shutdown.
         for driver in self._frontends:
             driver.quit()
@@ -517,7 +527,7 @@ class AppHarness:
         target: Callable[[], T],
         timeout: TimeoutType = None,
         step: TimeoutType = None,
-    ) -> T | bool:
+    ) -> T | Literal[False]:
         """Generic polling logic.
 
         Args:
@@ -535,9 +545,10 @@ class AppHarness:
             step = POLL_INTERVAL
         deadline = time.time() + timeout
         while time.time() < deadline:
-            success = target()
-            if success:
-                return success
+            with contextlib.suppress(Exception):
+                success = target()
+                if success:
+                    return success
             time.sleep(step)
         return False
 
@@ -840,6 +851,57 @@ class AppHarness:
             raise TimeoutError(msg)
         return state_manager.states
 
+    @staticmethod
+    def poll_for_or_raise_timeout(
+        target: Callable[[], T],
+        timeout: TimeoutType = None,
+        step: TimeoutType = None,
+    ) -> T:
+        """Poll target callable for a truthy return value.
+
+        Like `_poll_for`, but raises a `TimeoutError` if the target does not
+        return a truthy value within the timeout.
+
+        Args:
+            target: callable that returns truthy if polling condition is met.
+            timeout: max polling time
+            step: interval between checking target()
+
+        Returns:
+            return value of target() if truthy within timeout
+
+        Raises:
+            TimeoutError: when target does not return a truthy value within timeout
+        """
+        result = AppHarness._poll_for(
+            target=target,
+            timeout=timeout,
+            step=step,
+        )
+        if result is False:
+            msg = "Target did not return a truthy value while polling."
+            raise TimeoutError(msg)
+        return result
+
+    @staticmethod
+    def expect(
+        target: Callable[[], T],
+        timeout: TimeoutType = None,
+        step: TimeoutType = None,
+    ):
+        """Expect a target callable to return a truthy value within the timeout.
+
+        Args:
+            target: callable that returns truthy if polling condition is met.
+            timeout: max polling time
+            step: interval between checking target()
+        """
+        AppHarness.poll_for_or_raise_timeout(
+            target=target,
+            timeout=timeout,
+            step=step,
+        )
+
 
 class SimpleHTTPRequestHandlerCustomErrors(SimpleHTTPRequestHandler):
     """SimpleHTTPRequestHandler with custom error page handling."""
@@ -922,7 +984,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 +999,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 +1016,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 +1037,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 +1062,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: