reflex 0.7.13a1__py3-none-any.whl → 0.7.14__py3-none-any.whl

reflex/testing.py

@@ -28,6 +28,7 @@ import psutil
 import uvicorn
 
 import reflex
+import reflex.environment
 import reflex.reflex
 import reflex.utils.build
 import reflex.utils.exec
@@ -35,7 +36,8 @@ import reflex.utils.format
 import reflex.utils.prerequisites
 import reflex.utils.processes
 from reflex.components.component import CustomComponent
-from reflex.config import environment, get_config
+from reflex.config import get_config
+from reflex.environment import environment
 from reflex.state import (
     BaseState,
     StateManager,
@@ -155,9 +157,8 @@ class AppHarness:
                 app_name = f"{func_name}_{slug_suffix}"
                 app_name = re.sub(r"[^a-zA-Z0-9_]", "_", app_name)
             elif isinstance(app_source, str):
-                raise ValueError(
-                    "app_name must be provided when app_source is a string."
-                )
+                msg = "app_name must be provided when app_source is a string."
+                raise ValueError(msg)
             else:
                 app_name = app_source.__name__
 
@@ -285,7 +286,8 @@ class AppHarness:
             self.app_instance._state_manager, StateManagerRedis
         ):
             if self.app_instance._state is None:
-                raise RuntimeError("State is not set.")
+                msg = "State is not set."
+                raise RuntimeError(msg)
             # Create our own redis connection for testing.
             self.state_manager = StateManagerRedis.create(self.app_instance._state)
         else:
@@ -299,7 +301,8 @@ class AppHarness:
 
     def _get_backend_shutdown_handler(self):
         if self.backend is None:
-            raise RuntimeError("Backend was not initialized.")
+            msg = "Backend was not initialized."
+            raise RuntimeError(msg)
 
         original_shutdown = self.backend.shutdown
 
@@ -330,7 +333,8 @@ class AppHarness:
 
     def _start_backend(self, port: int = 0):
         if self.app_asgi is None:
-            raise RuntimeError("App was not initialized.")
+            msg = "App was not initialized."
+            raise RuntimeError(msg)
         self.backend = uvicorn.Server(
             uvicorn.Config(
                 app=self.app_asgi,
@@ -366,7 +370,8 @@ class AppHarness:
                 state=self.app_instance._state,
             )
             if not isinstance(self.app_instance.state_manager, StateManagerRedis):
-                raise RuntimeError("Failed to reset state manager.")
+                msg = "Failed to reset state manager."
+                raise RuntimeError(msg)
 
     def _start_frontend(self):
         # Set up the frontend.
@@ -406,7 +411,8 @@ class AppHarness:
                 config.deploy_url = self.frontend_url
                 break
         if self.frontend_url is None:
-            raise RuntimeError("Frontend did not start")
+            msg = "Frontend did not start"
+            raise RuntimeError(msg)
 
         def consume_frontend_output():
             while True:
@@ -578,20 +584,23 @@ class AppHarness:
             TimeoutError: when server or sockets are not ready
         """
         if self.backend is None:
-            raise RuntimeError("Backend is not running.")
+            msg = "Backend is not running."
+            raise RuntimeError(msg)
         backend = self.backend
         # check for servers to be initialized
         if not self._poll_for(
             target=lambda: getattr(backend, "servers", False),
             timeout=timeout,
         ):
-            raise TimeoutError("Backend servers are not initialized.")
+            msg = "Backend servers are not initialized."
+            raise TimeoutError(msg)
         # check for sockets to be listening
         if not self._poll_for(
             target=lambda: getattr(backend.servers[0], "sockets", False),
             timeout=timeout,
         ):
-            raise TimeoutError("Backend is not listening.")
+            msg = "Backend is not listening."
+            raise TimeoutError(msg)
         return backend.servers[0].sockets[0]
 
     def frontend(
@@ -619,12 +628,14 @@ class AppHarness:
             RuntimeError: when selenium is not importable or frontend is not running
         """
         if not has_selenium:
-            raise RuntimeError(
+            msg = (
                 "Frontend functionality requires `selenium` to be installed, "
                 "and it could not be imported."
             )
+            raise RuntimeError(msg)
         if self.frontend_url is None:
-            raise RuntimeError("Frontend is not running.")
+            msg = "Frontend is not running."
+            raise RuntimeError(msg)
         want_headless = False
         if environment.APP_HARNESS_HEADLESS.get():
             want_headless = True
@@ -650,7 +661,8 @@ class AppHarness:
             if want_headless:
                 driver_options.add_argument("headless")
         if driver_options is None:
-            raise RuntimeError(f"Could not determine options for {driver_clz}")
+            msg = f"Could not determine options for {driver_clz}"
+            raise RuntimeError(msg)
         if args := environment.APP_HARNESS_DRIVER_ARGS.get():
             for arg in args.split(","):
                 driver_options.add_argument(arg)
@@ -680,7 +692,8 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         try:
             return await self.state_manager.get_state(token)
         finally:
@@ -698,7 +711,8 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         state = await self.get_state(token)
         for key, value in kwargs.items():
             setattr(state, key, value)
@@ -722,9 +736,11 @@ class AppHarness:
             RuntimeError: when the app hasn't started running
         """
         if self.state_manager is None:
-            raise RuntimeError("state_manager is not set.")
+            msg = "state_manager is not set."
+            raise RuntimeError(msg)
         if self.app_instance is None:
-            raise RuntimeError("App is not running.")
+            msg = "App is not running."
+            raise RuntimeError(msg)
         app_state_manager = self.app_instance.state_manager
         if isinstance(self.state_manager, StateManagerRedis):
             # Temporarily replace the app's state manager with our own, since
@@ -761,9 +777,8 @@ class AppHarness:
             target=lambda: element.text != exp_not_equal,
             timeout=timeout,
         ):
-            raise TimeoutError(
-                f"{element} content remains {exp_not_equal!r} while polling.",
-            )
+            msg = f"{element} content remains {exp_not_equal!r} while polling."
+            raise TimeoutError(msg)
         return element.text
 
     def poll_for_value(
@@ -792,9 +807,8 @@ class AppHarness:
             target=lambda: element.get_attribute("value") not in exp_not_equal,
             timeout=timeout,
         ):
-            raise TimeoutError(
-                f"{element} content remains {exp_not_equal!r} while polling.",
-            )
+            msg = f"{element} content remains {exp_not_equal!r} while polling."
+            raise TimeoutError(msg)
         return element.get_attribute("value")
 
     def poll_for_clients(self, timeout: TimeoutType = None) -> dict[str, BaseState]:
@@ -812,15 +826,18 @@ class AppHarness:
             ValueError: when the state_manager is not a memory state manager
         """
         if self.app_instance is None:
-            raise RuntimeError("App is not running.")
+            msg = "App is not running."
+            raise RuntimeError(msg)
         state_manager = self.app_instance.state_manager
         if not isinstance(state_manager, (StateManagerMemory, StateManagerDisk)):
-            raise ValueError("Only works with memory or disk state manager")
+            msg = "Only works with memory or disk state manager"
+            raise ValueError(msg)
         if not self._poll_for(
             target=lambda: state_manager.states,
             timeout=timeout,
         ):
-            raise TimeoutError("No states were observed while polling.")
+            msg = "No states were observed while polling."
+            raise TimeoutError(msg)
         return state_manager.states
 
 
@@ -962,11 +979,13 @@ class AppHarnessProd(AppHarness):
     def _wait_frontend(self):
         self._poll_for(lambda: self.frontend_server is not None)
         if self.frontend_server is None or not self.frontend_server.socket.fileno():
-            raise RuntimeError("Frontend did not start")
+            msg = "Frontend did not start"
+            raise RuntimeError(msg)
 
     def _start_backend(self):
         if self.app_asgi is None:
-            raise RuntimeError("App was not initialized.")
+            msg = "App was not initialized."
+            raise RuntimeError(msg)
         environment.REFLEX_SKIP_COMPILE.set(True)
         self.backend = uvicorn.Server(
             uvicorn.Config(

reflex/utils/build.py

@@ -132,7 +132,7 @@ def _zip(
 def zip_app(
     frontend: bool = True,
     backend: bool = True,
-    zip_dest_dir: str | Path = Path.cwd(),
+    zip_dest_dir: str | Path | None = None,
     upload_db_file: bool = False,
 ):
     """Zip up the app.
@@ -143,6 +143,7 @@ def zip_app(
         zip_dest_dir: The directory to export the zip file to.
         upload_db_file: Whether to upload the database file.
     """
+    zip_dest_dir = zip_dest_dir or Path.cwd()
     zip_dest_dir = Path(zip_dest_dir)
     files_to_exclude = {
         constants.ComponentName.FRONTEND.zip(),

reflex/utils/console.py

@@ -15,6 +15,8 @@ from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
 from rich.prompt import Prompt
 
 from reflex.constants import LogLevel
+from reflex.constants.base import Reflex
+from reflex.utils.decorator import once
 
 # Console for pretty printing.
 _console = Console()
@@ -59,9 +61,8 @@ def set_log_level(log_level: LogLevel | None):
     if log_level is None:
         return
     if not isinstance(log_level, LogLevel):
-        raise TypeError(
-            f"log_level must be a LogLevel enum value, got {log_level} of type {type(log_level)} instead."
-        )
+        msg = f"log_level must be a LogLevel enum value, got {log_level} of type {type(log_level)} instead."
+        raise TypeError(msg)
     global _LOG_LEVEL
     if log_level != _LOG_LEVEL:
         # Set the loglevel persistenly for subprocesses.
@@ -89,11 +90,55 @@ def print(msg: str, dedupe: bool = False, **kwargs):
     if dedupe:
         if msg in _EMITTED_PRINTS:
             return
-        else:
-            _EMITTED_PRINTS.add(msg)
+        _EMITTED_PRINTS.add(msg)
     _console.print(msg, **kwargs)
 
 
+@once
+def log_file_console():
+    """Create a console that logs to a file.
+
+    Returns:
+        A Console object that logs to a file.
+    """
+    from reflex.environment import environment
+
+    if not (env_log_file := environment.REFLEX_LOG_FILE.get()):
+        subseconds = int((time.time() % 1) * 1000)
+        timestamp = time.strftime("%Y-%m-%d_%H-%M-%S") + f"_{subseconds:03d}"
+        log_file = Reflex.DIR / "logs" / (timestamp + ".log")
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+    else:
+        log_file = env_log_file
+    if log_file.exists():
+        log_file.unlink()
+    log_file.touch()
+    return Console(file=log_file.open("a", encoding="utf-8"))
+
+
+@once
+def should_use_log_file_console() -> bool:
+    """Check if the log file console should be used.
+
+    Returns:
+        True if the log file console should be used, False otherwise.
+    """
+    from reflex.environment import environment
+
+    return environment.REFLEX_ENABLE_FULL_LOGGING.get()
+
+
+def print_to_log_file(msg: str, dedupe: bool = False, **kwargs):
+    """Print a message to the log file.
+
+    Args:
+        msg: The message to print.
+        dedupe: If True, suppress multiple console logs of print message.
+        kwargs: Keyword arguments to pass to the print function.
+    """
+    log_file_console().print(msg, **kwargs)
+
+
 def debug(msg: str, dedupe: bool = False, **kwargs):
     """Print a debug message.
 
@@ -107,12 +152,13 @@ def debug(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg_ in _EMITTED_DEBUG:
                 return
-            else:
-                _EMITTED_DEBUG.add(msg_)
+            _EMITTED_DEBUG.add(msg_)
         if progress := kwargs.pop("progress", None):
             progress.console.print(msg_, **kwargs)
         else:
             print(msg_, **kwargs)
+    if should_use_log_file_console() and kwargs.pop("progress", None) is None:
+        print_to_log_file(f"[purple]Debug: {msg}[/purple]", **kwargs)
 
 
 def info(msg: str, dedupe: bool = False, **kwargs):
@@ -127,9 +173,10 @@ def info(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg in _EMITTED_INFO:
                 return
-            else:
-                _EMITTED_INFO.add(msg)
+            _EMITTED_INFO.add(msg)
         print(f"[cyan]Info: {msg}[/cyan]", **kwargs)
+    if should_use_log_file_console():
+        print_to_log_file(f"[cyan]Info: {msg}[/cyan]", **kwargs)
 
 
 def success(msg: str, dedupe: bool = False, **kwargs):
@@ -144,9 +191,10 @@ def success(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg in _EMITTED_SUCCESS:
                 return
-            else:
-                _EMITTED_SUCCESS.add(msg)
+            _EMITTED_SUCCESS.add(msg)
         print(f"[green]Success: {msg}[/green]", **kwargs)
+    if should_use_log_file_console():
+        print_to_log_file(f"[green]Success: {msg}[/green]", **kwargs)
 
 
 def log(msg: str, dedupe: bool = False, **kwargs):
@@ -161,9 +209,10 @@ def log(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg in _EMITTED_LOGS:
                 return
-            else:
-                _EMITTED_LOGS.add(msg)
+            _EMITTED_LOGS.add(msg)
         _console.log(msg, **kwargs)
+    if should_use_log_file_console():
+        print_to_log_file(msg, **kwargs)
 
 
 def rule(title: str, **kwargs):
@@ -188,9 +237,10 @@ def warn(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg in _EMIITED_WARNINGS:
                 return
-            else:
-                _EMIITED_WARNINGS.add(msg)
+            _EMIITED_WARNINGS.add(msg)
         print(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
+    if should_use_log_file_console():
+        print_to_log_file(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
 
 
 def _get_first_non_framework_frame() -> FrameType | None:
@@ -255,6 +305,8 @@ def deprecate(
         )
         if _LOG_LEVEL <= LogLevel.WARNING:
             print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
+        if should_use_log_file_console():
+            print_to_log_file(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
         if dedupe:
             _EMITTED_DEPRECATION_WARNINGS.add(dedupe_key)
 
@@ -271,9 +323,10 @@ def error(msg: str, dedupe: bool = False, **kwargs):
         if dedupe:
             if msg in _EMITTED_ERRORS:
                 return
-            else:
-                _EMITTED_ERRORS.add(msg)
+            _EMITTED_ERRORS.add(msg)
         print(f"[red]{msg}[/red]", **kwargs)
+    if should_use_log_file_console():
+        print_to_log_file(f"[red]{msg}[/red]", **kwargs)
 
 
 def ask(

reflex/utils/exec.py

@@ -12,13 +12,15 @@ import subprocess
 import sys
 from collections.abc import Sequence
 from pathlib import Path
+from typing import NamedTuple, TypedDict
 from urllib.parse import urljoin
 
 import psutil
 
 from reflex import constants
-from reflex.config import environment, get_config
+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.prerequisites import get_web_dir
@@ -27,26 +29,102 @@ from reflex.utils.prerequisites import get_web_dir
 frontend_process = None
 
 
-def detect_package_change(json_file_path: Path) -> str:
-    """Calculates the SHA-256 hash of a JSON file and returns it as a hexadecimal string.
+def get_package_json_and_hash(package_json_path: Path) -> tuple[PackageJson, str]:
+    """Get the content of package.json and its hash.
 
     Args:
-        json_file_path: The path to the JSON file to be hashed.
+        package_json_path: The path to the package.json file.
 
     Returns:
-        str: The SHA-256 hash of the JSON file as a hexadecimal string.
-
-    Example:
-        >>> detect_package_change("package.json")
-        'a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b8c9d0e1f2'
+        A tuple containing the content of package.json as a dictionary and its SHA-256 hash.
     """
-    with json_file_path.open("r") as file:
+    with package_json_path.open("r") as file:
         json_data = json.load(file)
 
     # Calculate the hash
     json_string = json.dumps(json_data, sort_keys=True)
     hash_object = hashlib.sha256(json_string.encode())
-    return hash_object.hexdigest()
+    return (json_data, hash_object.hexdigest())
+
+
+class PackageJson(TypedDict):
+    """package.json content."""
+
+    dependencies: dict[str, str]
+    devDependencies: dict[str, str]
+
+
+class Change(NamedTuple):
+    """A named tuple to represent a change in package dependencies."""
+
+    added: set[str]
+    removed: set[str]
+
+
+def format_change(name: str, change: Change) -> str:
+    """Format the change for display.
+
+    Args:
+        name: The name of the change (e.g., "dependencies" or "devDependencies").
+        change: The Change named tuple containing added and removed packages.
+
+    Returns:
+        A formatted string representing the changes.
+    """
+    if not change.added and not change.removed:
+        return ""
+    added_str = ", ".join(sorted(change.added))
+    removed_str = ", ".join(sorted(change.removed))
+    change_str = f"{name}:\n"
+    if change.added:
+        change_str += f"  Added: {added_str}\n"
+    if change.removed:
+        change_str += f"  Removed: {removed_str}\n"
+    return change_str.strip()
+
+
+def get_different_packages(
+    old_package_json_content: PackageJson,
+    new_package_json_content: PackageJson,
+) -> tuple[Change, Change]:
+    """Get the packages that are different between two package JSON contents.
+
+    Args:
+        old_package_json_content: The content of the old package JSON.
+        new_package_json_content: The content of the new package JSON.
+
+    Returns:
+        A tuple containing two `Change` named tuples:
+        - The first `Change` contains the changes in the `dependencies` section.
+        - The second `Change` contains the changes in the `devDependencies` section.
+    """
+
+    def get_changes(old: dict[str, str], new: dict[str, str]) -> Change:
+        """Get the changes between two dictionaries.
+
+        Args:
+            old: The old dictionary of packages.
+            new: The new dictionary of packages.
+
+        Returns:
+            A `Change` named tuple containing the added and removed packages.
+        """
+        old_keys = set(old.keys())
+        new_keys = set(new.keys())
+        added = new_keys - old_keys
+        removed = old_keys - new_keys
+        return Change(added=added, removed=removed)
+
+    dependencies_change = get_changes(
+        old_package_json_content.get("dependencies", {}),
+        new_package_json_content.get("dependencies", {}),
+    )
+    dev_dependencies_change = get_changes(
+        old_package_json_content.get("devDependencies", {}),
+        new_package_json_content.get("devDependencies", {}),
+    )
+
+    return dependencies_change, dev_dependencies_change
 
 
 def kill(proc_pid: int):
@@ -86,7 +164,7 @@ def run_process_and_launch_url(
     from reflex.utils import processes
 
     json_file_path = get_web_dir() / constants.PackageJson.PATH
-    last_hash = detect_package_change(json_file_path)
+    last_content, last_hash = get_package_json_and_hash(json_file_path)
     process = None
     first_run = True
 
@@ -105,6 +183,18 @@ def run_process_and_launch_url(
             frontend_process = process
         if process.stdout:
             for line in processes.stream_logs("Starting frontend", process):
+                new_content, new_hash = get_package_json_and_hash(json_file_path)
+                if new_hash != last_hash:
+                    dependencies_change, dev_dependencies_change = (
+                        get_different_packages(last_content, new_content)
+                    )
+                    last_content, last_hash = new_content, new_hash
+                    console.info(
+                        "Detected changes in package.json.\n"
+                        + format_change("Dependencies", dependencies_change)
+                        + format_change("Dev Dependencies", dev_dependencies_change)
+                    )
+
                 match = re.search(constants.Next.FRONTEND_LISTENING_REGEX, line)
                 if match:
                     if first_run:
@@ -119,22 +209,8 @@ def run_process_and_launch_url(
                             notify_backend()
                         first_run = False
                     else:
-                        console.print("New packages detected: Updating app...")
-                else:
-                    if any(
-                        x in line for x in ("bin executable does not exist on disk",)
-                    ):
-                        console.error(
-                            "Try setting `REFLEX_USE_NPM=1` and re-running `reflex init` and `reflex run` to use npm instead of bun:\n"
-                            "`REFLEX_USE_NPM=1 reflex init`\n"
-                            "`REFLEX_USE_NPM=1 reflex run`"
-                        )
-                    new_hash = detect_package_change(json_file_path)
-                    if new_hash != last_hash:
-                        last_hash = new_hash
-                        kill(process.pid)
-                        process = None
-                        break  # for line in process.stdout
+                        console.print("Frontend is restarting...")
+
         if process is not None:
             break  # while True
 
@@ -244,14 +320,12 @@ def get_app_file() -> Path:
         sys.path.insert(0, current_working_dir)
     module_spec = importlib.util.find_spec(get_app_module())
     if module_spec is None:
-        raise ImportError(
-            f"Module {get_app_module()} not found. Make sure the module is installed."
-        )
+        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
+        raise ImportError(msg)
     file_name = module_spec.origin
     if file_name is None:
-        raise ImportError(
-            f"Module {get_app_module()} not found. Make sure the module is installed."
-        )
+        msg = f"Module {get_app_module()} not found. Make sure the module is installed."
+        raise ImportError(msg)
     return Path(file_name).resolve()
 
 
@@ -300,13 +374,12 @@ def get_reload_paths() -> Sequence[Path]:
         The reload paths for the backend.
     """
     config = get_config()
-    reload_paths = [Path(config.app_name).parent]
-    if config.app_module is not None and config.app_module.__file__:
-        module_path = Path(config.app_module.__file__).resolve().parent
+    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.parent.iterdir()
+            sibling_file.name == "__init__.py" for sibling_file in module_path.iterdir()
         ):
             # go up a level to find dir without `__init__.py`
             module_path = module_path.parent
@@ -383,6 +456,7 @@ HOTRELOAD_IGNORE_EXTENSIONS = (
     "json",
     "sh",
     "bash",
+    "log",
 )
 
 HOTRELOAD_IGNORE_PATTERNS = (

reflex/utils/export.py

@@ -3,7 +3,8 @@
 from pathlib import Path
 
 from reflex import constants
-from reflex.config import environment, get_config
+from reflex.config import get_config
+from reflex.environment import environment
 from reflex.utils import build, console, exec, prerequisites, telemetry