reflex 0.5.4a3__py3-none-any.whl → 0.5.5a1__py3-none-any.whl

reflex/utils/build.py

@@ -18,7 +18,7 @@ from reflex.utils import console, path_ops, prerequisites, processes
 def set_env_json():
     """Write the upload url to a REFLEX_JSON."""
     path_ops.update_json_file(
-        constants.Dirs.ENV_JSON,
+        str(prerequisites.get_web_dir() / constants.Dirs.ENV_JSON),
         {endpoint.name: endpoint.get_url() for endpoint in constants.Endpoint},
     )
 
@@ -55,8 +55,8 @@ def generate_sitemap_config(deploy_url: str, export=False):
 
     config = json.dumps(config)
 
-    with open(constants.Next.SITEMAP_CONFIG_FILE, "w") as f:
-        f.write(templates.SITEMAP_CONFIG(config=config))
+    sitemap = prerequisites.get_web_dir() / constants.Next.SITEMAP_CONFIG_FILE
+    sitemap.write_text(templates.SITEMAP_CONFIG(config=config))
 
 
 def _zip(
@@ -129,85 +129,89 @@ def _zip(
             zipf.write(file, os.path.relpath(file, root_dir))
 
 
-def export(
-    backend: bool = True,
+def zip_app(
     frontend: bool = True,
-    zip: bool = False,
+    backend: bool = True,
     zip_dest_dir: str = os.getcwd(),
-    deploy_url: str | None = None,
     upload_db_file: bool = False,
 ):
-    """Export the app for deployment.
+    """Zip up the app.
 
     Args:
-        backend: Whether to zip up the backend app.
         frontend: Whether to zip up the frontend app.
-        zip: Whether to zip the app.
-        zip_dest_dir: The destination directory for created zip files (if any)
-        deploy_url: The URL of the deployed app.
-        upload_db_file: Whether to include local sqlite db files from the backend zip.
+        backend: Whether to zip up the backend app.
+        zip_dest_dir: The directory to export the zip file to.
+        upload_db_file: Whether to upload the database file.
     """
-    # Remove the static folder.
-    path_ops.rm(constants.Dirs.WEB_STATIC)
-
-    # The export command to run.
-    command = "export"
+    files_to_exclude = {
+        constants.ComponentName.FRONTEND.zip(),
+        constants.ComponentName.BACKEND.zip(),
+    }
 
     if frontend:
-        checkpoints = [
-            "Linting and checking ",
-            "Creating an optimized production build",
-            "Route (pages)",
-            "prerendered as static HTML",
-            "Collecting page data",
-            "Finalizing page optimization",
-            "Collecting build traces",
-        ]
+        _zip(
+            component_name=constants.ComponentName.FRONTEND,
+            target=os.path.join(zip_dest_dir, constants.ComponentName.FRONTEND.zip()),
+            root_dir=str(prerequisites.get_web_dir() / constants.Dirs.STATIC),
+            files_to_exclude=files_to_exclude,
+            exclude_venv_dirs=False,
+        )
 
-        # Generate a sitemap if a deploy URL is provided.
-        if deploy_url is not None:
-            generate_sitemap_config(deploy_url, export=zip)
-            command = "export-sitemap"
+    if backend:
+        _zip(
+            component_name=constants.ComponentName.BACKEND,
+            target=os.path.join(zip_dest_dir, constants.ComponentName.BACKEND.zip()),
+            root_dir=".",
+            dirs_to_exclude={"__pycache__"},
+            files_to_exclude=files_to_exclude,
+            top_level_dirs_to_exclude={"assets"},
+            exclude_venv_dirs=True,
+            upload_db_file=upload_db_file,
+        )
 
-            checkpoints.extend(["Loading next-sitemap", "Generation completed"])
 
-        # Start the subprocess with the progress bar.
-        process = processes.new_process(
-            [prerequisites.get_package_manager(), "run", command],
-            cwd=constants.Dirs.WEB,
-            shell=constants.IS_WINDOWS,
-        )
-        processes.show_progress("Creating Production Build", process, checkpoints)
-
-    # Zip up the app.
-    if zip:
-        files_to_exclude = {
-            constants.ComponentName.FRONTEND.zip(),
-            constants.ComponentName.BACKEND.zip(),
-        }
-        if frontend:
-            _zip(
-                component_name=constants.ComponentName.FRONTEND,
-                target=os.path.join(
-                    zip_dest_dir, constants.ComponentName.FRONTEND.zip()
-                ),
-                root_dir=constants.Dirs.WEB_STATIC,
-                files_to_exclude=files_to_exclude,
-                exclude_venv_dirs=False,
-            )
-        if backend:
-            _zip(
-                component_name=constants.ComponentName.BACKEND,
-                target=os.path.join(
-                    zip_dest_dir, constants.ComponentName.BACKEND.zip()
-                ),
-                root_dir=".",
-                dirs_to_exclude={"__pycache__"},
-                files_to_exclude=files_to_exclude,
-                top_level_dirs_to_exclude={"assets"},
-                exclude_venv_dirs=True,
-                upload_db_file=upload_db_file,
-            )
+def build(
+    deploy_url: str | None = None,
+    for_export: bool = False,
+):
+    """Build the app for deployment.
+
+    Args:
+        deploy_url: The deployment URL.
+        for_export: Whether the build is for export.
+    """
+    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"
+
+    checkpoints = [
+        "Linting and checking ",
+        "Creating an optimized production build",
+        "Route (pages)",
+        "prerendered as static HTML",
+        "Collecting page data",
+        "Finalizing page optimization",
+        "Collecting build traces",
+    ]
+
+    # 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_package_manager(), "run", command],
+        cwd=wdir,
+        shell=constants.IS_WINDOWS,
+    )
+    processes.show_progress("Creating Production Build", process, checkpoints)
 
 
 def setup_frontend(
@@ -226,7 +230,7 @@ def setup_frontend(
     # Copy asset files to public folder.
     path_ops.cp(
         src=str(root / constants.Dirs.APP_ASSETS),
-        dest=str(root / constants.Dirs.WEB_ASSETS),
+        dest=str(root / prerequisites.get_web_dir() / constants.Dirs.PUBLIC),
     )
 
     # Set the environment variables in client (env.json).
@@ -242,7 +246,7 @@ def setup_frontend(
                 "telemetry",
                 "disable",
             ],
-            cwd=constants.Dirs.WEB,
+            cwd=prerequisites.get_web_dir(),
             stdout=subprocess.DEVNULL,
             shell=constants.IS_WINDOWS,
         )
@@ -259,7 +263,7 @@ def setup_frontend_prod(
         disable_telemetry: Whether to disable the Next telemetry.
     """
     setup_frontend(root, disable_telemetry)
-    export(deploy_url=get_config().deploy_url)
+    build(deploy_url=get_config().deploy_url)
 
 
 def _looks_like_venv_dir(dir_to_check: str) -> bool:

reflex/utils/exec.py

@@ -17,6 +17,7 @@ import psutil
 from reflex import constants
 from reflex.config import get_config
 from reflex.utils import console, path_ops
+from reflex.utils.prerequisites import get_web_dir
 from reflex.utils.watch import AssetFolderWatch
 
 # For uvicorn windows bug fix (#2335)
@@ -82,8 +83,8 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
     """
     from reflex.utils import processes
 
-    json_file_path = os.path.join(constants.Dirs.WEB, "package.json")
-    last_hash = detect_package_change(json_file_path)
+    json_file_path = get_web_dir() / constants.PackageJson.PATH
+    last_hash = detect_package_change(str(json_file_path))
     process = None
     first_run = True
 
@@ -94,7 +95,7 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
                 kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore
             process = processes.new_process(
                 run_command,
-                cwd=constants.Dirs.WEB,
+                cwd=get_web_dir(),
                 shell=constants.IS_WINDOWS,
                 **kwargs,
             )
@@ -108,7 +109,14 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
                         url = match.group(1)
                         if get_config().frontend_path != "":
                             url = urljoin(url, get_config().frontend_path)
-                        console.print(f"App running at: [bold green]{url}")
+
+                        console.print(
+                            f"App running at: [bold green]{url}[/bold green]{' (Frontend-only mode)' if not backend_present else ''}"
+                        )
+                        if backend_present:
+                            console.print(
+                                f"Backend running at: [bold green]http://0.0.0.0:{get_config().backend_port}[/bold green]"
+                            )
                         first_run = False
                     else:
                         console.print("New packages detected: Updating app...")
@@ -121,7 +129,7 @@ def run_process_and_launch_url(run_command: list[str], backend_present=True):
                             "`REFLEX_USE_NPM=1 reflex init`\n"
                             "`REFLEX_USE_NPM=1 reflex run`"
                         )
-                    new_hash = detect_package_change(json_file_path)
+                    new_hash = detect_package_change(str(json_file_path))
                     if new_hash != last_hash:
                         last_hash = new_hash
                         kill(process.pid)
@@ -194,10 +202,10 @@ def run_backend(
     config = get_config()
     app_module = f"reflex.app_module_for_backend:{constants.CompileVars.APP}"
 
+    web_dir = get_web_dir()
     # Create a .nocompile file to skip compile for backend.
-    if os.path.exists(constants.Dirs.WEB):
-        with open(constants.NOCOMPILE_FILE, "w"):
-            pass
+    if web_dir.exists():
+        (web_dir / constants.NOCOMPILE_FILE).touch()
 
     # Run the backend in development mode.
     uvicorn.run(
@@ -207,7 +215,7 @@ def run_backend(
         log_level=loglevel.value,
         reload=True,
         reload_dirs=[config.app_name],
-        reload_excludes=[constants.Dirs.WEB],
+        reload_excludes=[str(web_dir)],
     )
 
 

reflex/utils/export.py

@@ -1,4 +1,5 @@
 """Export utilities."""
+
 import os
 from pathlib import Path
 from typing import Optional
@@ -55,15 +56,18 @@ def export(
         # Set up .web directory and install frontend dependencies.
         build.setup_frontend(Path.cwd())
 
-    # Export the app.
-    build.export(
-        backend=backend,
-        frontend=frontend,
-        zip=zipping,
-        zip_dest_dir=zip_dest_dir,
-        deploy_url=config.deploy_url,
-        upload_db_file=upload_db_file,
-    )
+    # Build the static app.
+    if frontend:
+        build.build(deploy_url=config.deploy_url, for_export=True)
+
+    # Zip up the app.
+    if zipping:
+        build.zip_app(
+            frontend=frontend,
+            backend=backend,
+            zip_dest_dir=zip_dest_dir,
+            upload_db_file=upload_db_file,
+        )
 
     # Post a telemetry event.
     telemetry.send("export")

reflex/utils/imports.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 from reflex.base import Base
 
 
-def merge_imports(*imports) -> ImportDict:
+def merge_imports(*imports: ImportDict | ParsedImportDict) -> ParsedImportDict:
     """Merge multiple import dicts together.
 
     Args:
@@ -24,7 +24,31 @@ def merge_imports(*imports) -> ImportDict:
     return all_imports
 
 
-def collapse_imports(imports: ImportDict) -> ImportDict:
+def parse_imports(imports: ImportDict | ParsedImportDict) -> ParsedImportDict:
+    """Parse the import dict into a standard format.
+
+    Args:
+        imports: The import dict to parse.
+
+    Returns:
+        The parsed import dict.
+    """
+
+    def _make_list(value: ImportTypes) -> list[str | ImportVar] | list[ImportVar]:
+        if isinstance(value, (str, ImportVar)):
+            return [value]
+        return value
+
+    return {
+        package: [
+            ImportVar(tag=tag) if isinstance(tag, str) else tag
+            for tag in _make_list(maybe_tags)
+        ]
+        for package, maybe_tags in imports.items()
+    }
+
+
+def collapse_imports(imports: ParsedImportDict) -> ParsedImportDict:
     """Remove all duplicate ImportVar within an ImportDict.
 
     Args:
@@ -33,7 +57,10 @@ def collapse_imports(imports: ImportDict) -> ImportDict:
     Returns:
         The collapsed import dict.
     """
-    return {lib: list(set(import_vars)) for lib, import_vars in imports.items()}
+    return {
+        lib: list(set(import_vars)) if isinstance(import_vars, list) else import_vars
+        for lib, import_vars in imports.items()
+    }
 
 
 class ImportVar(Base):
@@ -90,4 +117,6 @@ class ImportVar(Base):
         )
 
 
-ImportDict = Dict[str, List[ImportVar]]
+ImportTypes = Union[str, ImportVar, List[Union[str, ImportVar]], List[ImportVar]]
+ImportDict = Dict[str, ImportTypes]
+ParsedImportDict = Dict[str, List[ImportVar]]

reflex/utils/lazy_loader.py

@@ -1,4 +1,5 @@
 """Module to implement lazy loading in reflex."""
+
 import copy
 
 import lazy_loader as lazy

reflex/utils/path_ops.py

@@ -14,19 +14,20 @@ from reflex import constants
 join = os.linesep.join
 
 
-def rm(path: str):
+def rm(path: str | Path):
     """Remove a file or directory.
 
     Args:
         path: The path to the file or directory.
     """
-    if os.path.isdir(path):
+    path = Path(path)
+    if path.is_dir():
         shutil.rmtree(path)
-    elif os.path.isfile(path):
-        os.remove(path)
+    elif path.is_file():
+        path.unlink()
 
 
-def cp(src: str, dest: str, overwrite: bool = True) -> bool:
+def cp(src: str | Path, dest: str | Path, overwrite: bool = True) -> bool:
     """Copy a file or directory.
 
     Args:
@@ -37,11 +38,12 @@ def cp(src: str, dest: str, overwrite: bool = True) -> bool:
     Returns:
         Whether the copy was successful.
     """
+    src, dest = Path(src), Path(dest)
     if src == dest:
         return False
-    if not overwrite and os.path.exists(dest):
+    if not overwrite and dest.exists():
         return False
-    if os.path.isdir(src):
+    if src.is_dir():
         rm(dest)
         shutil.copytree(src, dest)
     else:
@@ -49,7 +51,7 @@ def cp(src: str, dest: str, overwrite: bool = True) -> bool:
     return True
 
 
-def mv(src: str, dest: str, overwrite: bool = True) -> bool:
+def mv(src: str | Path, dest: str | Path, overwrite: bool = True) -> bool:
     """Move a file or directory.
 
     Args:
@@ -60,25 +62,26 @@ def mv(src: str, dest: str, overwrite: bool = True) -> bool:
     Returns:
         Whether the move was successful.
     """
+    src, dest = Path(src), Path(dest)
     if src == dest:
         return False
-    if not overwrite and os.path.exists(dest):
+    if not overwrite and dest.exists():
         return False
     rm(dest)
     shutil.move(src, dest)
     return True
 
 
-def mkdir(path: str):
+def mkdir(path: str | Path):
     """Create a directory.
 
     Args:
         path: The path to the directory.
     """
-    os.makedirs(path, exist_ok=True)
+    Path(path).mkdir(parents=True, exist_ok=True)
 
 
-def ln(src: str, dest: str, overwrite: bool = False) -> bool:
+def ln(src: str | Path, dest: str | Path, overwrite: bool = False) -> bool:
     """Create a symbolic link.
 
     Args:
@@ -89,19 +92,20 @@ def ln(src: str, dest: str, overwrite: bool = False) -> bool:
     Returns:
         Whether the link was successful.
     """
+    src, dest = Path(src), Path(dest)
     if src == dest:
         return False
-    if not overwrite and (os.path.exists(dest) or os.path.islink(dest)):
+    if not overwrite and (dest.exists() or dest.is_symlink()):
         return False
-    if os.path.isdir(src):
+    if src.is_dir():
         rm(dest)
-        os.symlink(src, dest, target_is_directory=True)
+        src.symlink_to(dest, target_is_directory=True)
     else:
-        os.symlink(src, dest)
+        src.symlink_to(dest)
     return True
 
 
-def which(program: str) -> str | None:
+def which(program: str | Path) -> str | Path | None:
     """Find the path to an executable.
 
     Args:
@@ -110,7 +114,7 @@ def which(program: str) -> str | None:
     Returns:
         The path to the executable.
     """
-    return shutil.which(program)
+    return shutil.which(str(program))
 
 
 def get_node_bin_path() -> str | None:
@@ -119,10 +123,11 @@ def get_node_bin_path() -> str | None:
     Returns:
         The path to the node bin folder.
     """
-    if not os.path.exists(constants.Node.BIN_PATH):
+    bin_path = Path(constants.Node.BIN_PATH)
+    if not bin_path.exists():
         str_path = which("node")
         return str(Path(str_path).parent.resolve()) if str_path else str_path
-    return str(Path(constants.Node.BIN_PATH).resolve())
+    return str(bin_path.resolve())
 
 
 def get_node_path() -> str | None:
@@ -131,9 +136,10 @@ def get_node_path() -> str | None:
     Returns:
         The path to the node binary file.
     """
-    if not os.path.exists(constants.Node.PATH):
-        return which("node")
-    return constants.Node.PATH
+    node_path = Path(constants.Node.PATH)
+    if not node_path.exists():
+        return str(which("node"))
+    return str(node_path)
 
 
 def get_npm_path() -> str | None:
@@ -142,12 +148,13 @@ def get_npm_path() -> str | None:
     Returns:
         The path to the npm binary file.
     """
-    if not os.path.exists(constants.Node.PATH):
-        return which("npm")
-    return constants.Node.NPM_PATH
+    npm_path = Path(constants.Node.NPM_PATH)
+    if not npm_path.exists():
+        return str(which("npm"))
+    return str(npm_path)
 
 
-def update_json_file(file_path: str, update_dict: dict[str, int | str]):
+def update_json_file(file_path: str | Path, update_dict: dict[str, int | str]):
     """Update the contents of a json file.
 
     Args:
@@ -176,7 +183,7 @@ def update_json_file(file_path: str, update_dict: dict[str, int | str]):
         json.dump(json_object, f, ensure_ascii=False)
 
 
-def find_replace(directory: str, find: str, replace: str):
+def find_replace(directory: str | Path, find: str, replace: str):
     """Recursively find and replace text in files in a directory.
 
     Args:
@@ -184,11 +191,10 @@ def find_replace(directory: str, find: str, replace: str):
         find: The text to find.
         replace: The text to replace.
     """
+    directory = Path(directory)
     for root, _dirs, files in os.walk(directory):
         for file in files:
-            filepath = os.path.join(root, file)
-            with open(filepath, "r", encoding="utf-8") as f:
-                text = f.read()
+            filepath = Path(root, file)
+            text = filepath.read_text(encoding="utf-8")
             text = re.sub(find, replace, text)
-            with open(filepath, "w") as f:
-                f.write(text)
+            filepath.write_text(text)