reflex 0.8.6a0__py3-none-any.whl → 0.8.7a1__py3-none-any.whl

reflex/plugins/_screenshot.py

@@ -0,0 +1,144 @@
+"""Plugin to enable screenshot functionality."""
+
+from typing import TYPE_CHECKING
+
+from reflex.plugins.base import Plugin as BasePlugin
+
+if TYPE_CHECKING:
+    from starlette.requests import Request
+    from starlette.responses import Response
+    from typing_extensions import Unpack
+
+    from reflex.app import App
+    from reflex.plugins.base import PostCompileContext
+    from reflex.state import BaseState
+
+ACTIVE_CONNECTIONS = "/_active_connections"
+CLONE_STATE = "/_clone_state"
+
+
+def _deep_copy(state: "BaseState") -> "BaseState":
+    """Create a deep copy of the state.
+
+    Args:
+        state: The state to copy.
+
+    Returns:
+        A deep copy of the state.
+    """
+    import copy
+
+    copy_of_state = copy.deepcopy(state)
+
+    def copy_substate(substate: "BaseState") -> "BaseState":
+        substate_copy = _deep_copy(substate)
+
+        substate_copy.parent_state = copy_of_state
+
+        return substate_copy
+
+    copy_of_state.substates = {
+        substate_name: copy_substate(substate)
+        for substate_name, substate in state.substates.items()
+    }
+
+    return copy_of_state
+
+
+class ScreenshotPlugin(BasePlugin):
+    """Plugin to handle screenshot functionality."""
+
+    def post_compile(self, **context: "Unpack[PostCompileContext]") -> None:
+        """Called after the compilation of the plugin.
+
+        Args:
+            context: The context for the plugin.
+        """
+        app = context["app"]
+        self._add_active_connections_endpoint(app)
+        self._add_clone_state_endpoint(app)
+
+    @staticmethod
+    def _add_active_connections_endpoint(app: "App") -> None:
+        """Add an endpoint to the app that returns the active connections.
+
+        Args:
+            app: The application instance to which the endpoint will be added.
+        """
+        if not app._api:
+            return
+
+        async def active_connections(_request: "Request") -> "Response":
+            from starlette.responses import JSONResponse
+
+            if not app.event_namespace:
+                return JSONResponse({})
+
+            return JSONResponse(app.event_namespace.token_to_sid)
+
+        app._api.add_route(
+            ACTIVE_CONNECTIONS,
+            active_connections,
+            methods=["GET"],
+        )
+
+    @staticmethod
+    def _add_clone_state_endpoint(app: "App") -> None:
+        """Add an endpoint to the app that clones the current state.
+
+        Args:
+            app: The application instance to which the endpoint will be added.
+        """
+        if not app._api:
+            return
+
+        async def clone_state(request: "Request") -> "Response":
+            import uuid
+
+            from starlette.responses import JSONResponse
+
+            from reflex.state import _substate_key
+
+            if not app.event_namespace:
+                return JSONResponse({})
+
+            token_to_clone = await request.json()
+
+            if not isinstance(token_to_clone, str):
+                return JSONResponse(
+                    {"error": "Token to clone must be a string."}, status_code=400
+                )
+
+            old_state = await app.state_manager.get_state(token_to_clone)
+
+            new_state = _deep_copy(old_state)
+
+            new_token = uuid.uuid4().hex
+
+            all_states = [new_state]
+
+            found_new = True
+
+            while found_new:
+                found_new = False
+
+                for state in all_states:
+                    for substate in state.substates.values():
+                        substate._was_touched = True
+
+                        if substate not in all_states:
+                            all_states.append(substate)
+
+                            found_new = True
+
+            await app.state_manager.set_state(
+                _substate_key(new_token, new_state), new_state
+            )
+
+            return JSONResponse(new_token)
+
+        app._api.add_route(
+            CLONE_STATE,
+            clone_state,
+            methods=["POST"],
+        )

reflex/plugins/base.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, ParamSpec, Protocol, TypedDict
 from typing_extensions import Unpack
 
 if TYPE_CHECKING:
-    from reflex.app import UnevaluatedPage
+    from reflex.app import App, UnevaluatedPage
 
 
 class CommonContext(TypedDict):
@@ -44,6 +44,12 @@ class PreCompileContext(CommonContext):
     unevaluated_pages: Sequence["UnevaluatedPage"]
 
 
+class PostCompileContext(CommonContext):
+    """Context for post-compile hooks."""
+
+    app: "App"
+
+
 class Plugin:
     """Base class for all plugins."""
 
@@ -104,6 +110,13 @@ class Plugin:
             context: The context for the plugin.
         """
 
+    def post_compile(self, **context: Unpack[PostCompileContext]) -> None:
+        """Called after the compilation of the plugin.
+
+        Args:
+            context: The context for the plugin.
+        """
+
     def __repr__(self):
         """Return a string representation of the plugin.
 

reflex/reflex.py

@@ -58,7 +58,7 @@ def _init(
     ai: bool = False,
 ):
     """Initialize a new Reflex app in the given directory."""
-    from reflex.utils import exec, prerequisites
+    from reflex.utils import exec, frontend_skeleton, prerequisites, templates
 
     # Show system info
     exec.output_system_info()
@@ -80,13 +80,13 @@ def _init(
     prerequisites.initialize_frontend_dependencies()
 
     # Initialize the app.
-    template = prerequisites.initialize_app(app_name, template)
+    template = templates.initialize_app(app_name, template)
 
     # Initialize the .gitignore.
-    prerequisites.initialize_gitignore()
+    frontend_skeleton.initialize_gitignore()
 
     # Initialize the requirements.txt.
-    needs_user_manual_update = prerequisites.initialize_requirements_txt()
+    needs_user_manual_update = frontend_skeleton.initialize_requirements_txt()
 
     template_msg = f" using the {template} template" if template else ""
     # Finish initializing the app.
@@ -371,7 +371,7 @@ def compile(dry: bool):
         _init(name=get_config().app_name)
     get_config(reload=True)
     starting_time = time.monotonic()
-    prerequisites.compile_app(dry_run=dry)
+    prerequisites.get_compiled_app(dry_run=dry)
     elapsed_time = time.monotonic() - starting_time
     console.success(f"App compiled successfully in {elapsed_time:.3f} seconds.")
 
@@ -737,9 +737,10 @@ def deploy(
 def rename(new_name: str):
     """Rename the app in the current directory."""
     from reflex.utils import prerequisites
+    from reflex.utils.rename import rename_app
 
     prerequisites.validate_app_name(new_name)
-    prerequisites.rename_app(new_name, get_config().loglevel)
+    rename_app(new_name, get_config().loglevel)
 
 
 if TYPE_CHECKING:

reflex/route.py

@@ -6,6 +6,7 @@ import re
 from collections.abc import Callable
 
 from reflex import constants
+from reflex.config import get_config
 
 
 def verify_route_validity(route: str) -> None:
@@ -211,6 +212,9 @@ def get_router(routes: list[str]) -> Callable[[str], str | None]:
         Returns:
             The first matching route, or None if no match is found.
         """
+        config = get_config()
+        if config.frontend_path:
+            path = path.removeprefix(config.frontend_path)
         path = "/" + path.removeprefix("/").removesuffix("/")
         if path == "/index":
             path = "/"

reflex/state.py

@@ -509,7 +509,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         new_backend_vars = {
             name: value
-            for name, value in cls.__dict__.items()
+            for name, value in list(cls.__dict__.items())
             if types.is_backend_base_variable(name, cls)
         }
         # Add annotated backend vars that may not have a default value.
@@ -2491,7 +2491,7 @@ class OnLoadInternalState(State):
         # Cache the app reference for subsequent calls.
         if type(self)._app_ref is None:
             type(self)._app_ref = app
-        load_events = app.get_load_events(self.router._page.path)
+        load_events = app.get_load_events(self.router.url.path)
         if not load_events:
             self.is_hydrated = True
             return None  # Fast path for navigation with no on_load events defined.

reflex/testing.py

@@ -45,7 +45,7 @@ from reflex.state import (
     StateManagerRedis,
     reload_state_module,
 )
-from reflex.utils import console
+from reflex.utils import console, js_runtimes
 from reflex.utils.export import export
 from reflex.utils.types import ASGIApp
 
@@ -403,9 +403,7 @@ class AppHarness:
         # Start the frontend.
         self.frontend_process = reflex.utils.processes.new_process(
             [
-                *reflex.utils.prerequisites.get_js_package_executor(raise_on_none=True)[
-                    0
-                ],
+                *js_runtimes.get_js_package_executor(raise_on_none=True)[0],
                 "run",
                 "dev",
             ],
@@ -1010,7 +1008,7 @@ class AppHarnessProd(AppHarness):
             / reflex.constants.Dirs.STATIC
         )
         error_page_map = {
-            404: web_root / "404" / "index.html",
+            404: web_root / "404.html",
         }
         with Subdir404TCPServer(
             ("", 0),

reflex/utils/build.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 import os
 import zipfile
-from pathlib import Path
+from pathlib import Path, PosixPath
 
 from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 
 from reflex import constants
-from reflex.utils import console, path_ops, prerequisites, processes
+from reflex.config import get_config
+from reflex.utils import console, js_runtimes, path_ops, prerequisites, processes
 from reflex.utils.exec import is_in_app_harness
 
 
@@ -187,7 +188,7 @@ def build():
     # Start the subprocess with the progress bar.
     process = processes.new_process(
         [
-            *prerequisites.get_js_package_executor(raise_on_none=True)[0],
+            *js_runtimes.get_js_package_executor(raise_on_none=True)[0],
             "run",
             "export",
         ],
@@ -200,6 +201,23 @@ def build():
     )
     processes.show_progress("Creating Production Build", process, checkpoints)
     _duplicate_index_html_to_parent_dir(wdir / constants.Dirs.STATIC)
+    path_ops.cp(
+        wdir / constants.Dirs.STATIC / constants.ReactRouter.SPA_FALLBACK,
+        wdir / constants.Dirs.STATIC / "404.html",
+    )
+
+    config = get_config()
+
+    if frontend_path := config.frontend_path.strip("/"):
+        frontend_path = PosixPath(frontend_path)
+        first_part = frontend_path.parts[0]
+        for child in list((wdir / constants.Dirs.STATIC).iterdir()):
+            if child.is_dir() and child.name == first_part:
+                continue
+            path_ops.mv(
+                child,
+                wdir / constants.Dirs.STATIC / frontend_path / child.name,
+            )
 
 
 def setup_frontend(

reflex/utils/exec.py

@@ -231,17 +231,17 @@ def run_frontend(root: Path, port: str, backend_present: bool = True):
         port: The port to run the frontend on.
         backend_present: Whether the backend is present.
     """
-    from reflex.utils import prerequisites
+    from reflex.utils import js_runtimes
 
     # validate dependencies before run
-    prerequisites.validate_frontend_dependencies(init=False)
+    js_runtimes.validate_frontend_dependencies(init=False)
 
     # Run the frontend in development mode.
     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_js_package_executor(raise_on_none=True)[0],
+            *js_runtimes.get_js_package_executor(raise_on_none=True)[0],
             "run",
             "dev",
         ],
@@ -257,16 +257,16 @@ def run_frontend_prod(root: Path, port: str, backend_present: bool = True):
         port: The port to run the frontend on.
         backend_present: Whether the backend is present.
     """
-    from reflex.utils import prerequisites
+    from reflex.utils import js_runtimes
 
     # Set the port.
     os.environ["PORT"] = str(get_config().frontend_port if port is None else port)
     # validate dependencies before run
-    prerequisites.validate_frontend_dependencies(init=False)
+    js_runtimes.validate_frontend_dependencies(init=False)
     # Run the frontend in production mode.
     console.rule("[bold green]App Running")
     run_process_and_launch_url(
-        [*prerequisites.get_js_package_executor(raise_on_none=True)[0], "run", "prod"],
+        [*js_runtimes.get_js_package_executor(raise_on_none=True)[0], "run", "prod"],
         backend_present,
     )
 
@@ -670,7 +670,7 @@ def output_system_info():
     if console._LOG_LEVEL > constants.LogLevel.DEBUG:
         return
 
-    from reflex.utils import prerequisites
+    from reflex.utils import js_runtimes
 
     config = get_config()
     try:
@@ -684,13 +684,13 @@ def output_system_info():
 
     dependencies = [
         f"[Reflex {constants.Reflex.VERSION} with Python {platform.python_version()} (PATH: {sys.executable})]",
-        f"[Node {prerequisites.get_node_version()} (Minimum: {constants.Node.MIN_VERSION}) (PATH:{path_ops.get_node_path()})]",
+        f"[Node {js_runtimes.get_node_version()} (Minimum: {constants.Node.MIN_VERSION}) (PATH:{path_ops.get_node_path()})]",
     ]
 
     system = platform.system()
 
     dependencies.append(
-        f"[Bun {prerequisites.get_bun_version()} (Minimum: {constants.Bun.MIN_VERSION}) (PATH: {path_ops.get_bun_path()})]"
+        f"[Bun {js_runtimes.get_bun_version()} (Minimum: {constants.Bun.MIN_VERSION}) (PATH: {path_ops.get_bun_path()})]"
     )
 
     if system == "Linux":
@@ -704,10 +704,10 @@ def output_system_info():
         console.debug(f"{dep}")
 
     console.debug(
-        f"Using package installer at: {prerequisites.get_nodejs_compatible_package_managers(raise_on_none=False)}"
+        f"Using package installer at: {js_runtimes.get_nodejs_compatible_package_managers(raise_on_none=False)}"
     )
     console.debug(
-        f"Using package executer at: {prerequisites.get_js_package_executor(raise_on_none=False)}"
+        f"Using package executer at: {js_runtimes.get_js_package_executor(raise_on_none=False)}"
     )
     if system != "Windows":
         console.debug(f"Unzip path: {path_ops.which('unzip')}")

reflex/utils/frontend_skeleton.py

@@ -0,0 +1,254 @@
+"""This module provides utility functions to initialize the frontend skeleton."""
+
+import json
+import random
+import re
+from pathlib import Path
+
+import click
+
+from reflex import constants
+from reflex.compiler import templates
+from reflex.config import Config, get_config
+from reflex.utils import console, path_ops
+from reflex.utils.prerequisites import get_project_hash, get_web_dir
+from reflex.utils.registry import get_npm_registry
+
+
+def initialize_gitignore(
+    gitignore_file: Path = constants.GitIgnore.FILE,
+    files_to_ignore: set[str] | list[str] = constants.GitIgnore.DEFAULTS,
+):
+    """Initialize the template .gitignore file.
+
+    Args:
+        gitignore_file: The .gitignore file to create.
+        files_to_ignore: The files to add to the .gitignore file.
+    """
+    # Combine with the current ignored files.
+    current_ignore: list[str] = []
+    if gitignore_file.exists():
+        current_ignore = [ln.strip() for ln in gitignore_file.read_text().splitlines()]
+
+    if files_to_ignore == current_ignore:
+        console.debug(f"{gitignore_file} already up to date.")
+        return
+    files_to_ignore = [ln for ln in files_to_ignore if ln not in current_ignore]
+    files_to_ignore += current_ignore
+
+    # Write files to the .gitignore file.
+    gitignore_file.touch(exist_ok=True)
+    console.debug(f"Creating {gitignore_file}")
+    gitignore_file.write_text("\n".join(files_to_ignore) + "\n")
+
+
+def initialize_requirements_txt() -> bool:
+    """Initialize the requirements.txt file.
+    If absent and no pyproject.toml file exists, generate one for the user.
+    If the requirements.txt does not have reflex as dependency,
+    generate a requirement pinning current version and append to
+    the requirements.txt file.
+
+    Returns:
+        True if the user has to update the requirements.txt file.
+
+    Raises:
+        Exit: If the requirements.txt file cannot be read or written to.
+    """
+    requirements_file_path = Path(constants.RequirementsTxt.FILE)
+    if (
+        not requirements_file_path.exists()
+        and Path(constants.PyprojectToml.FILE).exists()
+    ):
+        return True
+
+    requirements_file_path.touch(exist_ok=True)
+
+    for encoding in [None, "utf-8"]:
+        try:
+            content = requirements_file_path.read_text(encoding)
+            break
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            console.error(f"Failed to read {requirements_file_path}.")
+            raise click.exceptions.Exit(1) from e
+    else:
+        return True
+
+    for line in content.splitlines():
+        if re.match(r"^reflex[^a-zA-Z0-9]", line):
+            console.debug(f"{requirements_file_path} already has reflex as dependency.")
+            return False
+
+    console.debug(
+        f"Appending {constants.RequirementsTxt.DEFAULTS_STUB} to {requirements_file_path}"
+    )
+    with requirements_file_path.open("a", encoding=encoding) as f:
+        f.write(
+            "\n" + constants.RequirementsTxt.DEFAULTS_STUB + constants.Reflex.VERSION
+        )
+
+    return False
+
+
+def initialize_web_directory():
+    """Initialize the web directory on reflex init."""
+    console.log("Initializing the web directory.")
+
+    # Reuse the hash if one is already created, so we don't over-write it when running reflex init
+    project_hash = get_project_hash()
+
+    console.debug(f"Copying {constants.Templates.Dirs.WEB_TEMPLATE} to {get_web_dir()}")
+    path_ops.copy_tree(constants.Templates.Dirs.WEB_TEMPLATE, str(get_web_dir()))
+
+    console.debug("Initializing the web directory.")
+    initialize_package_json()
+
+    console.debug("Initializing the bun config file.")
+    initialize_bun_config()
+
+    console.debug("Initializing the .npmrc file.")
+    initialize_npmrc()
+
+    console.debug("Initializing the public directory.")
+    path_ops.mkdir(get_web_dir() / constants.Dirs.PUBLIC)
+
+    console.debug("Initializing the react-router.config.js file.")
+    update_react_router_config()
+
+    console.debug("Initializing the vite.config.js file.")
+    initialize_vite_config()
+
+    console.debug("Initializing the reflex.json file.")
+    # Initialize the reflex json file.
+    init_reflex_json(project_hash=project_hash)
+
+
+def update_react_router_config(prerender_routes: bool = False):
+    """Update react-router.config.js config from Reflex config.
+
+    Args:
+        prerender_routes: Whether to enable prerendering of routes.
+    """
+    react_router_config_file_path = get_web_dir() / constants.ReactRouter.CONFIG_FILE
+
+    new_react_router_config = _update_react_router_config(
+        get_config(), prerender_routes=prerender_routes
+    )
+
+    # Overwriting the config file triggers a full server reload, so make sure
+    # there is actually a diff.
+    old_react_router_config = (
+        react_router_config_file_path.read_text()
+        if react_router_config_file_path.exists()
+        else ""
+    )
+    if old_react_router_config != new_react_router_config:
+        react_router_config_file_path.write_text(new_react_router_config)
+
+
+def _update_react_router_config(config: Config, prerender_routes: bool = False):
+    basename = "/" + (config.frontend_path or "").strip("/")
+    if not basename.endswith("/"):
+        basename += "/"
+
+    react_router_config = {
+        "basename": basename,
+        "future": {
+            "unstable_optimizeDeps": True,
+        },
+        "ssr": False,
+    }
+
+    if prerender_routes:
+        react_router_config["prerender"] = True
+        react_router_config["build"] = constants.Dirs.BUILD_DIR
+
+    return f"export default {json.dumps(react_router_config)};"
+
+
+def _compile_package_json():
+    return templates.PACKAGE_JSON.render(
+        scripts={
+            "dev": constants.PackageJson.Commands.DEV,
+            "export": constants.PackageJson.Commands.EXPORT,
+            "prod": constants.PackageJson.Commands.PROD,
+        },
+        dependencies=constants.PackageJson.DEPENDENCIES,
+        dev_dependencies=constants.PackageJson.DEV_DEPENDENCIES,
+        overrides=constants.PackageJson.OVERRIDES,
+    )
+
+
+def initialize_package_json():
+    """Render and write in .web the package.json file."""
+    output_path = get_web_dir() / constants.PackageJson.PATH
+    output_path.write_text(_compile_package_json())
+
+
+def _compile_vite_config(config: Config):
+    # base must have exactly one trailing slash
+    base = "/"
+    if frontend_path := config.frontend_path.strip("/"):
+        base += frontend_path + "/"
+    return templates.VITE_CONFIG.render(base=base)
+
+
+def initialize_vite_config():
+    """Render and write in .web the vite.config.js file using Reflex config."""
+    vite_config_file_path = get_web_dir() / constants.ReactRouter.VITE_CONFIG_FILE
+    vite_config_file_path.write_text(_compile_vite_config(get_config()))
+
+
+def initialize_bun_config():
+    """Initialize the bun config file."""
+    bun_config_path = get_web_dir() / constants.Bun.CONFIG_PATH
+
+    if (custom_bunfig := Path(constants.Bun.CONFIG_PATH)).exists():
+        bunfig_content = custom_bunfig.read_text()
+        console.info(f"Copying custom bunfig.toml inside {get_web_dir()} folder")
+    else:
+        best_registry = get_npm_registry()
+        bunfig_content = constants.Bun.DEFAULT_CONFIG.format(registry=best_registry)
+
+    bun_config_path.write_text(bunfig_content)
+
+
+def initialize_npmrc():
+    """Initialize the .npmrc file."""
+    npmrc_path = get_web_dir() / constants.Node.CONFIG_PATH
+
+    if (custom_npmrc := Path(constants.Node.CONFIG_PATH)).exists():
+        npmrc_content = custom_npmrc.read_text()
+        console.info(f"Copying custom .npmrc inside {get_web_dir()} folder")
+    else:
+        best_registry = get_npm_registry()
+        npmrc_content = constants.Node.DEFAULT_CONFIG.format(registry=best_registry)
+
+    npmrc_path.write_text(npmrc_content)
+
+
+def init_reflex_json(project_hash: int | None):
+    """Write the hash of the Reflex project to a REFLEX_JSON.
+
+    Reuse the hash if one is already created, therefore do not
+    overwrite it every time we run the reflex init command
+    .
+
+    Args:
+        project_hash: The app hash.
+    """
+    if project_hash is not None:
+        console.debug(f"Project hash is already set to {project_hash}.")
+    else:
+        # Get a random project hash.
+        project_hash = random.getrandbits(128)
+        console.debug(f"Setting project hash to {project_hash}.")
+
+    # Write the hash and version to the reflex json file.
+    reflex_json = {
+        "version": constants.Reflex.VERSION,
+        "project_hash": project_hash,
+    }
+    path_ops.update_json_file(get_web_dir() / constants.Reflex.JSON, reflex_json)