reflex 0.7.4a1__py3-none-any.whl → 0.7.4a3__py3-none-any.whl

reflex/.templates/web/components/reflex/radix_themes_color_mode_provider.js

@@ -1,5 +1,5 @@
 import { useTheme } from "next-themes";
-import { useEffect, useState } from "react";
+import { useRef, useEffect, useState } from "react";
 import {
   ColorModeContext,
   defaultColorMode,
@@ -13,6 +13,14 @@ export default function RadixThemesColorModeProvider({ children }) {
   const [resolvedColorMode, setResolvedColorMode] = useState(
     defaultColorMode === "dark" ? "dark" : "light",
   );
+  const firstUpdate = useRef(true);
+  useEffect(() => {
+    if (firstUpdate.current) {
+      firstUpdate.current = false;
+      setRawColorMode(theme);
+      setResolvedColorMode(resolvedTheme);
+    }
+  });
 
   useEffect(() => {
     if (isDevMode) {

reflex/app.py

@@ -968,7 +968,7 @@ class App(MiddlewareMixin, LifespanMixin):
         # Check the nocompile file.
         if nocompile.exists():
             # Delete the nocompile file
-            nocompile.unlink()
+            nocompile.unlink(missing_ok=True)
             return False
 
         # By default, compile the app.
@@ -1108,8 +1108,6 @@ class App(MiddlewareMixin, LifespanMixin):
         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:
@@ -1258,7 +1256,9 @@ class App(MiddlewareMixin, LifespanMixin):
             compiler.compile_document_root(
                 self.head_components,
                 html_lang=self.html_lang,
-                html_custom_attrs=self.html_custom_attrs,  # pyright: ignore [reportArgumentType]
+                html_custom_attrs=(
+                    {**self.html_custom_attrs} if self.html_custom_attrs else {}
+                ),
             )
         )
 

reflex/base.py

@@ -38,7 +38,7 @@ def validate_field_name(bases: list[Type["BaseModel"]], field_name: str) -> None
 
 # monkeypatch pydantic validate_field_name method to skip validating
 # shadowed state vars when reloading app via utils.prerequisites.get_app(reload=True)
-pydantic_main.validate_field_name = validate_field_name  # pyright: ignore [reportPossiblyUnboundVariable, reportPrivateImportUsage]
+pydantic_main.validate_field_name = validate_field_name  # pyright: ignore [reportPrivateImportUsage]
 
 if TYPE_CHECKING:
     from reflex.vars import Var
@@ -107,7 +107,7 @@ class Base(BaseModel):
             default_value: The default value of the field
         """
         var_name = var._var_field_name
-        new_field = ModelField.infer(  # pyright: ignore [reportPossiblyUnboundVariable]
+        new_field = ModelField.infer(
             name=var_name,
             value=default_value,
             annotation=var._var_type,
@@ -128,5 +128,5 @@ class Base(BaseModel):
         if isinstance(key, str):
             # Seems like this function signature was wrong all along?
             # If the user wants a field that we know of, get it and pass it off to _get_value
-            return getattr(self, key, key)
+            return getattr(self, key)
         return key

reflex/compiler/compiler.py

@@ -20,6 +20,7 @@ from reflex.config import environment, get_config
 from reflex.state import BaseState
 from reflex.style import SYSTEM_COLOR_MODE
 from reflex.utils import console, path_ops
+from reflex.utils.exceptions import ReflexError
 from reflex.utils.exec import is_prod_mode
 from reflex.utils.imports import ImportVar
 from reflex.utils.prerequisites import get_web_dir
@@ -651,6 +652,8 @@ def into_component(component: Component | ComponentCallable) -> Component:
         ):
             return converted
     except KeyError as e:
+        if isinstance(e, ReflexError):
+            raise
         key = e.args[0] if e.args else None
         if key is not None and isinstance(key, Var):
             raise TypeError(
@@ -658,6 +661,8 @@ def into_component(component: Component | ComponentCallable) -> Component:
             ).with_traceback(e.__traceback__) from None
         raise
     except TypeError as e:
+        if isinstance(e, ReflexError):
+            raise
         message = e.args[0] if e.args else None
         if message and isinstance(message, str):
             if message.endswith("has no len()") and (

reflex/components/component.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import copy
 import dataclasses
 import functools
@@ -1974,13 +1975,15 @@ class NoSSRComponent(Component):
         # Do NOT import the main library/tag statically.
         import_name = self._get_import_name()
         if import_name is not None:
-            _imports[import_name] = [
+            with contextlib.suppress(ValueError):
+                _imports[import_name].remove(self.import_var)
+            _imports[import_name].append(
                 imports.ImportVar(
                     tag=None,
                     render=False,
                     transpile=self._should_transpile(self.library),
-                ),
-            ]
+                )
+            )
 
         return imports.merge_imports(
             dynamic_import,

reflex/config.py

@@ -44,7 +44,7 @@ from reflex.utils.types import (
 )
 
 try:
-    from dotenv import load_dotenv  # pyright: ignore [reportMissingImports]
+    from dotenv import load_dotenv
 except ImportError:
     load_dotenv = None
 
@@ -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/reflex.py

@@ -205,18 +205,22 @@ def _run(
     prerequisites.check_latest_package_version(constants.Reflex.MODULE_NAME)
 
     # Get the app module.
-    app_task = prerequisites.compile_app if frontend else prerequisites.validate_app
+    app_task = prerequisites.compile_or_validate_app
+    args = (frontend,)
 
     # Granian fails if the app is already imported.
     if should_use_granian():
         import concurrent.futures
 
         compile_future = concurrent.futures.ProcessPoolExecutor(max_workers=1).submit(
-            app_task
+            app_task,
+            *args,
         )
-        compile_future.result()
+        validation_result = compile_future.result()
     else:
-        app_task()
+        validation_result = app_task(*args)
+    if not validation_result:
+        raise typer.Exit(1)
 
     # Warn if schema is not up to date.
     prerequisites.check_schema_up_to_date()

reflex/state.py

@@ -907,7 +907,7 @@ class BaseState(Base, ABC, extra=pydantic.Extra.allow):
             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/exec.py

@@ -189,9 +189,11 @@ def run_frontend_prod(root: Path, port: str, backend_present: bool = True):
 
 @once
 def _warn_user_about_uvicorn():
-    console.warn(
-        "Using Uvicorn for backend as it is installed. This behavior will change in 0.8.0 to use Granian by default."
-    )
+    # When we eventually switch to Granian by default, we should enable this warning.
+    if False:
+        console.warn(
+            "Using Uvicorn for backend as it is installed. This behavior will change in 0.8.0 to use Granian by default."
+        )
 
 
 def should_use_granian():
@@ -357,70 +359,74 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
     ).serve()
 
 
+def _deprecate_asgi_config(
+    config_name: str,
+    reason: str = "",
+):
+    # When we eventually switch to Granian by default, we should enable this deprecation.
+    if False:
+        console.deprecate(
+            f"config.{config_name}",
+            reason=reason,
+            deprecation_version="0.7.5",
+            removal_version="0.8.0",
+        )
+
+
 @once
 def _get_backend_workers():
     from reflex.utils import processes
 
     config = get_config()
 
+    gunicorn_workers = config.gunicorn_workers or 0
+
     if config.gunicorn_workers is not None:
-        console.deprecate(
-            "config.gunicorn_workers",
-            reason="If you're using Granian, use GRANIAN_WORKERS instead.",
-            deprecation_version="0.7.4",
-            removal_version="0.8.0",
+        _deprecate_asgi_config(
+            "gunicorn_workers",
+            "If you're using Granian, use GRANIAN_WORKERS instead.",
         )
 
-    return (
-        processes.get_num_workers()
-        if not config.gunicorn_workers
-        else config.gunicorn_workers
-    )
+    return gunicorn_workers if gunicorn_workers else processes.get_num_workers()
 
 
 @once
 def _get_backend_timeout():
     config = get_config()
 
+    timeout = config.timeout or 120
+
     if config.timeout is not None:
-        console.deprecate(
-            "config.timeout",
-            reason="If you're using Granian, use GRANIAN_WORKERS_LIFETIME instead.",
-            deprecation_version="0.7.4",
-            removal_version="0.8.0",
+        _deprecate_asgi_config(
+            "timeout",
+            "If you're using Granian, use GRANIAN_WORKERS_LIFETIME instead.",
         )
 
-    return config.timeout
+    return timeout
 
 
 @once
 def _get_backend_max_requests():
     config = get_config()
 
+    gunicorn_max_requests = config.gunicorn_max_requests or 120
+
     if config.gunicorn_max_requests is not None:
-        console.deprecate(
-            "config.gunicorn_max_requests",
-            reason="",
-            deprecation_version="0.7.4",
-            removal_version="0.8.0",
-        )
+        _deprecate_asgi_config("gunicorn_max_requests")
 
-    return config.gunicorn_max_requests
+    return gunicorn_max_requests
 
 
 @once
 def _get_backend_max_requests_jitter():
     config = get_config()
 
+    gunicorn_max_requests_jitter = config.gunicorn_max_requests_jitter or 25
+
     if config.gunicorn_max_requests_jitter is not None:
-        console.deprecate(
-            "config.gunicorn_max_requests_jitter",
-            reason="",
-            deprecation_version="0.7.4",
-            removal_version="0.8.0",
-        )
+        _deprecate_asgi_config("gunicorn_max_requests_jitter")
 
-    return config.gunicorn_max_requests_jitter
+    return gunicorn_max_requests_jitter
 
 
 def run_backend_prod(

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

@@ -8,6 +8,7 @@ import functools
 import importlib
 import importlib.metadata
 import importlib.util
+import io
 import json
 import os
 import platform
@@ -114,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
@@ -128,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
 
 
@@ -183,7 +187,7 @@ def get_node_version() -> version.Version | None:
     try:
         result = processes.new_process([node_path, "-v"], run=True)
         # The output will be in the form "vX.Y.Z", but version.parse() can handle it
-        return version.parse(result.stdout)  # pyright: ignore [reportArgumentType]
+        return version.parse(result.stdout)
     except (FileNotFoundError, TypeError):
         return None
 
@@ -200,7 +204,7 @@ def get_bun_version() -> version.Version | None:
     try:
         # Run the bun -v command and capture the output
         result = processes.new_process([str(bun_path), "-v"], run=True)
-        return version.parse(str(result.stdout))  # pyright: ignore [reportArgumentType]
+        return version.parse(str(result.stdout))
     except FileNotFoundError:
         return None
     except version.InvalidVersion as e:
@@ -449,6 +453,76 @@ def compile_app(reload: bool = False, export: bool = False) -> None:
     get_compiled_app(reload=reload, export=export)
 
 
+def _can_colorize() -> bool:
+    """Check if the output can be colorized.
+
+    Copied from _colorize.can_colorize.
+
+    https://raw.githubusercontent.com/python/cpython/refs/heads/main/Lib/_colorize.py
+
+    Returns:
+        If the output can be colorized
+    """
+    file = sys.stdout
+
+    if not sys.flags.ignore_environment:
+        if os.environ.get("PYTHON_COLORS") == "0":
+            return False
+        if os.environ.get("PYTHON_COLORS") == "1":
+            return True
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("FORCE_COLOR"):
+        return True
+    if os.environ.get("TERM") == "dumb":
+        return False
+
+    if not hasattr(file, "fileno"):
+        return False
+
+    if sys.platform == "win32":
+        try:
+            import nt
+
+            if not nt._supports_virtual_terminal():
+                return False
+        except (ImportError, AttributeError):
+            return False
+
+    try:
+        return os.isatty(file.fileno())
+    except io.UnsupportedOperation:
+        return file.isatty()
+
+
+def compile_or_validate_app(compile: bool = False) -> bool:
+    """Compile or validate the app module based on the default config.
+
+    Args:
+        compile: Whether to compile the app.
+
+    Returns:
+        If the app is compiled successfully.
+    """
+    try:
+        if compile:
+            compile_app()
+        else:
+            validate_app()
+    except Exception as e:
+        import traceback
+
+        sys_exception = sys.exception()
+
+        try:
+            colorize = _can_colorize()
+            traceback.print_exception(e, colorize=colorize)  # pyright: ignore[reportCallIssue]
+        except Exception:
+            traceback.print_exception(sys_exception)
+        return False
+    return True
+
+
 def get_redis() -> Redis | None:
     """Get the asynchronous redis client.
 
@@ -831,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.
@@ -879,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)
 
@@ -1321,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"
 
@@ -1347,6 +1429,7 @@ 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())
 
@@ -1354,9 +1437,11 @@ def initialize_reflex_user_directory():
 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()