reflex 0.7.14a2__tar.gz → 0.7.14a3__tar.gz

{reflex-0.7.14a2 → reflex-0.7.14a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex
-Version: 0.7.14a2
+Version: 0.7.14a3
 Summary: Web apps in pure Python.
 Project-URL: homepage, https://reflex.dev
 Project-URL: repository, https://github.com/reflex-dev/reflex

{reflex-0.7.14a2 → reflex-0.7.14a3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reflex"
-version = "0.7.14a2"
+version = "0.7.14a3"
 description = "Web apps in pure Python."
 license.text = "Apache-2.0"
 authors = [

{reflex-0.7.14a2 → reflex-0.7.14a3}/reflex/components/component.py

@@ -2206,6 +2206,14 @@ class CustomComponent(Component):
         component._add_style_recursive(style)
         return component
 
+    def _get_all_app_wrap_components(self) -> dict[tuple[int, str], Component]:
+        """Get the app wrap components for the custom component.
+
+        Returns:
+            The app wrap components.
+        """
+        return self.get_component()._get_all_app_wrap_components()
+
 
 CUSTOM_COMPONENTS: dict[str, CustomComponent] = {}
 

{reflex-0.7.14a2 → reflex-0.7.14a3}/reflex/config.py

@@ -766,6 +766,12 @@ class EnvironmentVariables:
     # Whether to run Granian in a spawn process. This enables Reflex to pick up on environment variable changes between hot reloads.
     REFLEX_STRICT_HOT_RELOAD: EnvVar[bool] = env_var(False)
 
+    # The path to the reflex log file. If not set, the log file will be stored in the reflex user directory.
+    REFLEX_LOG_FILE: EnvVar[Path | None] = env_var(None)
+
+    # Enable full logging of debug messages to reflex user directory.
+    REFLEX_ENABLE_FULL_LOGGING: EnvVar[bool] = env_var(False)
+
 
 environment = EnvironmentVariables()
 

{reflex-0.7.14a2 → reflex-0.7.14a3}/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()
@@ -92,6 +94,51 @@ def print(msg: str, dedupe: bool = False, **kwargs):
     _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.config 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.config 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.
 
@@ -110,6 +157,8 @@ def debug(msg: str, dedupe: bool = False, **kwargs):
             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):
@@ -126,6 +175,8 @@ def info(msg: str, dedupe: bool = False, **kwargs):
                 return
             _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):
@@ -142,6 +193,8 @@ def success(msg: str, dedupe: bool = False, **kwargs):
                 return
             _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):
@@ -158,6 +211,8 @@ def log(msg: str, dedupe: bool = False, **kwargs):
                 return
             _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):
@@ -184,6 +239,8 @@ def warn(msg: str, dedupe: bool = False, **kwargs):
                 return
             _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:
@@ -248,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)
 
@@ -266,6 +325,8 @@ def error(msg: str, dedupe: bool = False, **kwargs):
                 return
             _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-0.7.14a2 → reflex-0.7.14a3}/reflex/utils/exec.py

@@ -12,6 +12,7 @@ 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
@@ -27,26 +28,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 +163,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 +182,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 +208,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
 

{reflex-0.7.14a2 → reflex-0.7.14a3}/reflex/utils/telemetry.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
+import importlib.metadata
 import multiprocessing
 import platform
 import warnings
@@ -76,6 +77,18 @@ def get_cpu_count() -> int:
     return multiprocessing.cpu_count()
 
 
+def get_reflex_enterprise_version() -> str | None:
+    """Get the version of reflex-enterprise if installed.
+
+    Returns:
+        The version string if installed, None if not installed.
+    """
+    try:
+        return importlib.metadata.version("reflex-enterprise")
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
 def get_memory() -> int:
     """Get the total memory in MB.
 
@@ -113,6 +126,7 @@ class _Properties(TypedDict):
     python_version: str
     node_version: str | None
     bun_version: str | None
+    reflex_enterprise_version: str | None
     cpu_count: int
     memory: int
     cpu_info: dict
@@ -166,6 +180,7 @@ def _get_event_defaults() -> _DefaultEvent | None:
             "bun_version": (
                 str(bun_version) if (bun_version := get_bun_version()) else None
             ),
+            "reflex_enterprise_version": get_reflex_enterprise_version(),
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
             "cpu_info": dataclasses.asdict(cpuinfo) if cpuinfo else {},