Merge branch 'main' into release/reflex-0.7.4

Author: adhami3310

pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
   "distro >=1.8.0,<2.0; platform_system == 'Linux'",
   "fastapi >=0.96.0,!=0.111.0,!=0.111.1",
   "granian[reload] >=2.0.0",
+  "gunicorn >=23.0.0,<24.0.0",
   "httpx >=0.25.1,<1.0",
   "jinja2 >=3.1.2,<4.0",
   "lazy_loader >=0.4",
@@ -46,6 +47,7 @@ dependencies = [
   "twine >=4.0.0,<7.0",
   "typer >=0.15.1,<1.0",
   "typing_extensions >=4.6.0",
+  "uvicorn >=0.20.0",
   "wheel >=0.42.0,<1.0",
   "wrapt >=1.17.0,<2.0",
 ]
@@ -161,5 +163,4 @@ dev = [
   "ruff ==0.11.0",
   "selenium >=4.11.0,<5.0",
   "toml >=0.10.2,<1.0",
-  "uvicorn >=0.20.0",
 ]

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 @@ def _should_compile(self) -> bool:
         # 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.
@@ -1258,7 +1258,9 @@ def memoized_toast_provider():
             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 @@ def add_field(cls, var: Var, default_value: Any):
             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 @@ def get_value(self, key: str) -> Any:
         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.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,13 +652,17 @@ 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(
                 "Cannot access a primitive map with a Var. Consider calling rx.Var.create() on the map."
             ).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 @@ def _get_imports(self) -> ParsedImportDict:
         # 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 @@
 )
 
 try:
-    from dotenv import load_dotenv  # pyright: ignore [reportMissingImports]
+    from dotenv import load_dotenv
 except ImportError:
     load_dotenv = None
 

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/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(