Merge branch 'main' into release/reflex-0.7.4

Author: adhami3310

reflex/app.py

@@ -1108,8 +1108,6 @@ def get_compilation_time() -> str:
         if config.react_strict_mode:
             app_wrappers[(200, "StrictMode")] = StrictMode.create()
 
-        should_compile = self._should_compile()
-
         if not should_compile:
             with console.timing("Evaluate Pages (Backend)"):
                 for route in self._unevaluated_pages:

reflex/config.py

@@ -720,6 +720,9 @@ class EnvironmentVariables:
     # Used by flexgen to enumerate the pages.
     REFLEX_ADD_ALL_ROUTES_ENDPOINT: EnvVar[bool] = env_var(False)
 
+    # The address to bind the HTTP client to. You can set this to "::" to enable IPv6.
+    REFLEX_HTTP_CLIENT_BIND_ADDRESS: EnvVar[str | None] = env_var(None)
+
 
 environment = EnvironmentVariables()
 

reflex/state.py

@@ -907,7 +907,7 @@ def get_parent_state(cls) -> Type[BaseState] | None:
             raise ValueError(f"Only one parent state is allowed {parent_states}.")
         # The first non-mixin state in the mro is our parent.
         for base in cls.mro()[1:]:
-            if base._mixin or not issubclass(base, BaseState):
+            if not issubclass(base, BaseState) or base._mixin:
                 continue
             if base is BaseState:
                 break

reflex/utils/net.py

@@ -1,8 +1,13 @@
 """Helpers for downloading files from the network."""
 
+import functools
+import time
+from typing import Callable, ParamSpec, TypeVar
+
 import httpx
 
-from ..config import environment
+from reflex.utils.decorator import once
+
 from . import console
 
 
@@ -12,30 +17,114 @@ def _httpx_verify_kwarg() -> bool:
     Returns:
         True if SSL verification is enabled, False otherwise
     """
+    from ..config import environment
+
     return not environment.SSL_NO_VERIFY.get()
 
 
-def get(url: str, **kwargs) -> httpx.Response:
-    """Make an HTTP GET request.
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+def _wrap_https_func(
+    func: Callable[_P, _T],
+) -> Callable[_P, _T]:
+    """Wrap an HTTPS function with logging.
 
     Args:
-        url: The URL to request.
-        **kwargs: Additional keyword arguments to pass to httpx.get.
+        func: The function to wrap.
 
     Returns:
-        The response object.
+        The wrapped function.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+        url = args[0]
+        console.debug(f"Sending HTTPS request to {args[0]}")
+        initial_time = time.time()
+        try:
+            response = func(*args, **kwargs)
+        except httpx.ConnectError as err:
+            if "CERTIFICATE_VERIFY_FAILED" in str(err):
+                # If the error is a certificate verification error, recommend mitigating steps.
+                console.error(
+                    f"Certificate verification failed for {url}. Set environment variable SSL_CERT_FILE to the "
+                    "path of the certificate file or SSL_NO_VERIFY=1 to disable verification."
+                )
+            raise
+        else:
+            console.debug(
+                f"Received response from {url} in {time.time() - initial_time:.3f} seconds"
+            )
+            return response
+
+    return wrapper
+
 
-    Raises:
-        httpx.ConnectError: If the connection cannot be established.
+def _is_ipv4_supported() -> bool:
+    """Determine if the system supports IPv4.
+
+    Returns:
+        True if the system supports IPv4, False otherwise.
     """
-    kwargs.setdefault("verify", _httpx_verify_kwarg())
     try:
-        return httpx.get(url, **kwargs)
-    except httpx.ConnectError as err:
-        if "CERTIFICATE_VERIFY_FAILED" in str(err):
-            # If the error is a certificate verification error, recommend mitigating steps.
-            console.error(
-                f"Certificate verification failed for {url}. Set environment variable SSL_CERT_FILE to the "
-                "path of the certificate file or SSL_NO_VERIFY=1 to disable verification."
-            )
-        raise
+        httpx.head("http://1.1.1.1", timeout=3)
+    except httpx.RequestError:
+        return False
+    else:
+        return True
+
+
+def _is_ipv6_supported() -> bool:
+    """Determine if the system supports IPv6.
+
+    Returns:
+        True if the system supports IPv6, False otherwise.
+    """
+    try:
+        httpx.head("http://[2606:4700:4700::1111]", timeout=3)
+    except httpx.RequestError:
+        return False
+    else:
+        return True
+
+
+def _should_use_ipv6() -> bool:
+    """Determine if the system supports IPv6.
+
+    Returns:
+        True if the system supports IPv6, False otherwise.
+    """
+    return not _is_ipv4_supported() and _is_ipv6_supported()
+
+
+def _httpx_local_address_kwarg() -> str:
+    """Get the value of the HTTPX local_address keyword argument.
+
+    Returns:
+        The local address to bind to
+    """
+    from ..config import environment
+
+    return environment.REFLEX_HTTP_CLIENT_BIND_ADDRESS.get() or (
+        "::" if _should_use_ipv6() else "0.0.0.0"
+    )
+
+
+@once
+def _httpx_client() -> httpx.Client:
+    """Get an HTTPX client.
+
+    Returns:
+        An HTTPX client.
+    """
+    return httpx.Client(
+        transport=httpx.HTTPTransport(
+            local_address=_httpx_local_address_kwarg(),
+            verify=_httpx_verify_kwarg(),
+        )
+    )
+
+
+get = _wrap_https_func(_httpx_client().get)

reflex/utils/prerequisites.py

@@ -115,11 +115,13 @@ def check_latest_package_version(package_name: str):
     if environment.REFLEX_CHECK_LATEST_VERSION.get() is False:
         return
     try:
+        console.debug(f"Checking for the latest version of {package_name}...")
         # Get the latest version from PyPI
         current_version = importlib.metadata.version(package_name)
         url = f"https://pypi.org/pypi/{package_name}/json"
         response = net.get(url)
         latest_version = response.json()["info"]["version"]
+        console.debug(f"Latest version of {package_name}: {latest_version}")
         if get_or_set_last_reflex_version_check_datetime():
             # Versions were already checked and saved in reflex.json, no need to warn again
             return
@@ -129,6 +131,7 @@ def check_latest_package_version(package_name: str):
                 f"Your version ({current_version}) of {package_name} is out of date. Upgrade to {latest_version} with 'pip install {package_name} --upgrade'"
             )
     except Exception:
+        console.debug(f"Failed to check for the latest version of {package_name}.")
         pass
 
 
@@ -902,11 +905,12 @@ def initialize_app_directory(
 
     console.debug(f"Using {template_name=} {template_dir=} {template_code_dir_name=}.")
 
-    # Remove all pyc and __pycache__ dirs in template directory.
-    for pyc_file in template_dir.glob("**/*.pyc"):
-        pyc_file.unlink()
-    for pycache_dir in template_dir.glob("**/__pycache__"):
-        pycache_dir.rmdir()
+    # Remove __pycache__ dirs in template directory and current directory.
+    for pycache_dir in [
+        *template_dir.glob("**/__pycache__"),
+        *Path.cwd().glob("**/__pycache__"),
+    ]:
+        shutil.rmtree(pycache_dir, ignore_errors=True)
 
     for file in template_dir.iterdir():
         # Copy the file to current directory but keep the name the same.
@@ -950,16 +954,22 @@ def initialize_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.cp(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 public directory.")
     path_ops.mkdir(get_web_dir() / constants.Dirs.PUBLIC)
 
+    console.debug("Initializing the next.config.js file.")
     update_next_config()
 
+    console.debug("Initializing the reflex.json file.")
     # Initialize the reflex json file.
     init_reflex_json(project_hash=project_hash)
 
@@ -1392,6 +1402,7 @@ def ensure_reflex_installation_id() -> int | None:
         Distinct id.
     """
     try:
+        console.debug("Ensuring reflex installation id.")
         initialize_reflex_user_directory()
         installation_id_file = environment.REFLEX_DIR.get() / "installation_id"
 
@@ -1418,16 +1429,19 @@ def ensure_reflex_installation_id() -> int | None:
 
 def initialize_reflex_user_directory():
     """Initialize the reflex user directory."""
+    console.debug(f"Creating {environment.REFLEX_DIR.get()}")
     # Create the reflex directory.
     path_ops.mkdir(environment.REFLEX_DIR.get())
 
 
 def initialize_frontend_dependencies():
     """Initialize all the frontend dependencies."""
     # validate dependencies before install
+    console.debug("Validating frontend dependencies.")
     validate_frontend_dependencies()
     # Install the frontend dependencies.
-    processes.run_concurrently(install_bun)
+    console.debug("Installing or validating bun.")
+    install_bun()
     # Set up the web directory.
     initialize_web_directory()
 

reflex/utils/redir.py

@@ -5,6 +5,8 @@
 
 import httpx
 
+from reflex.utils import net
+
 from .. import constants
 from . import console
 
@@ -38,7 +40,7 @@ def open_browser_and_wait(
     console.info("[b]Complete the workflow in the browser to continue.[/b]")
     while True:
         try:
-            response = httpx.get(poll_url, follow_redirects=True)
+            response = net.get(poll_url, follow_redirects=True)
             if response.is_success:
                 break
         except httpx.RequestError as err:

reflex/utils/registry.py

@@ -16,10 +16,13 @@ def latency(registry: str) -> int:
         int: The latency of the registry in microseconds.
     """
     try:
-        return net.get(registry).elapsed.microseconds
+        time_to_respond = net.get(registry, timeout=2).elapsed.microseconds
     except httpx.HTTPError:
         console.info(f"Failed to connect to {registry}.")
         return 10_000_000
+    else:
+        console.debug(f"Latency of {registry}: {time_to_respond}")
+        return time_to_respond
 
 
 def average_latency(registry: str, attempts: int = 3) -> int:
@@ -32,7 +35,9 @@ def average_latency(registry: str, attempts: int = 3) -> int:
     Returns:
         The average latency of the registry in microseconds.
     """
-    return sum(latency(registry) for _ in range(attempts)) // attempts
+    registry_latency = sum(latency(registry) for _ in range(attempts)) // attempts
+    console.debug(f"Average latency of {registry}: {registry_latency}")
+    return registry_latency
 
 
 def _get_best_registry() -> str:
@@ -41,12 +46,15 @@ def _get_best_registry() -> str:
     Returns:
         The best registry.
     """
+    console.debug("Getting best registry...")
     registries = [
         "https://registry.npmjs.org",
         "https://r.cnpmjs.org",
     ]
 
-    return min(registries, key=average_latency)
+    best_registry = min(registries, key=average_latency)
+    console.debug(f"Best registry: {best_registry}")
+    return best_registry
 
 
 def get_npm_registry() -> str:

tests/units/test_state.py

@@ -3436,6 +3436,30 @@ class GrandchildUsesMixinState(ChildMixinState):
     pass
 
 
+class BareMixin:
+    """A bare mixin which does not inherit from rx.State."""
+
+    _bare_mixin: int = 0
+
+
+class BareStateMixin(BareMixin, rx.State, mixin=True):
+    """A state mixin that uses a bare mixin."""
+
+    pass
+
+
+class BareMixinState(BareStateMixin, State):
+    """A state that uses a bare mixin."""
+
+    pass
+
+
+class ChildBareMixinState(BareMixinState):
+    """A child state that uses a bare mixin."""
+
+    pass
+
+
 def test_mixin_state() -> None:
     """Test that a mixin state works correctly."""
     assert "num" in UsesMixinState.base_vars
@@ -3481,6 +3505,21 @@ def test_grandchild_mixin_state() -> None:
     assert GrandchildUsesMixinState.get_root_state() == State
 
 
+def test_bare_mixin_state() -> None:
+    """Test that a mixin can inherit from a concrete state class."""
+    assert "_bare_mixin" not in BareMixinState.inherited_vars
+    assert "_bare_mixin" not in BareMixinState.base_vars
+
+    assert BareMixinState.get_parent_state() == State
+    assert BareMixinState.get_root_state() == State
+
+    assert "_bare_mixin" not in ChildBareMixinState.inherited_vars
+    assert "_bare_mixin" not in ChildBareMixinState.base_vars
+
+    assert ChildBareMixinState.get_parent_state() == BareMixinState
+    assert ChildBareMixinState.get_root_state() == State
+
+
 def test_assignment_to_undeclared_vars():
     """Test that an attribute error is thrown when undeclared vars are set."""