reflex 0.8.8a2__py3-none-any.whl → 0.8.9a2__py3-none-any.whl

reflex/components/lucide/icon.py

@@ -453,6 +453,7 @@ LUCIDE_ICON_LIST = [
     "chevrons_up_down",
     "chevrons_up",
     "chrome",
+    "chromium",
     "church",
     "cigarette_off",
     "cigarette",
@@ -1198,11 +1199,13 @@ LUCIDE_ICON_LIST = [
     "panel_left_close",
     "panel_left_dashed",
     "panel_left_open",
+    "panel_left_right_dashed",
     "panel_left",
     "panel_right_close",
     "panel_right_dashed",
     "panel_right_open",
     "panel_right",
+    "panel_top_bottom_dashed",
     "panel_top_close",
     "panel_top_dashed",
     "panel_top_open",

reflex/components/lucide/icon.pyi

@@ -518,6 +518,7 @@ LUCIDE_ICON_LIST = [
     "chevrons_up_down",
     "chevrons_up",
     "chrome",
+    "chromium",
     "church",
     "cigarette_off",
     "cigarette",
@@ -1263,11 +1264,13 @@ LUCIDE_ICON_LIST = [
     "panel_left_close",
     "panel_left_dashed",
     "panel_left_open",
+    "panel_left_right_dashed",
     "panel_left",
     "panel_right_close",
     "panel_right_dashed",
     "panel_right_open",
     "panel_right",
+    "panel_top_bottom_dashed",
     "panel_top_close",
     "panel_top_dashed",
     "panel_top_open",

reflex/components/radix/primitives/drawer.pyi

@@ -249,6 +249,7 @@ class DrawerPortal(DrawerComponent):
         """
 
 class DrawerContent(DrawerComponent):
+    def add_style(self) -> dict: ...
     @classmethod
     def create(
         cls,
@@ -309,6 +310,7 @@ class DrawerContent(DrawerComponent):
         """
 
 class DrawerOverlay(DrawerComponent):
+    def add_style(self) -> dict: ...
     @classmethod
     def create(
         cls,
@@ -411,6 +413,7 @@ class DrawerClose(DrawerTrigger):
         """
 
 class DrawerTitle(DrawerComponent):
+    def add_style(self) -> dict: ...
     @classmethod
     def create(
         cls,
@@ -462,6 +465,7 @@ class DrawerTitle(DrawerComponent):
         """
 
 class DrawerDescription(DrawerComponent):
+    def add_style(self) -> dict: ...
     @classmethod
     def create(
         cls,

reflex/config.py

@@ -237,7 +237,7 @@ class BaseConfig:
     env_file: str | None = None
 
     # Whether to automatically create setters for state base vars
-    state_auto_setters: bool = True
+    state_auto_setters: bool | None = None
 
     # Whether to display the sticky "Built with Reflex" badge on all pages.
     show_built_with_reflex: bool | None = None
@@ -267,9 +267,12 @@ _PLUGINS_ENABLED_BY_DEFAULT = [
 
 @dataclasses.dataclass(kw_only=True, init=False)
 class Config(BaseConfig):
-    """The config defines runtime settings for the app.
+    """Configuration class for Reflex applications.
 
-    By default, the config is defined in an `rxconfig.py` file in the root of the app.
+    The config defines runtime settings for your app including server ports, database connections,
+    frontend packages, and deployment settings.
+
+    By default, the config is defined in an `rxconfig.py` file in the root of your app:
 
     ```python
     # rxconfig.py
@@ -277,14 +280,38 @@ class Config(BaseConfig):
 
     config = rx.Config(
         app_name="myapp",
-        api_url="http://localhost:8000",
+        # Server configuration
+        frontend_port=3000,
+        backend_port=8000,
+        # Database
+        db_url="postgresql://user:pass@localhost:5432/mydb",
+        # Additional frontend packages
+        frontend_packages=["react-icons"],
+        # CORS settings for production
+        cors_allowed_origins=["https://mydomain.com"],
     )
     ```
 
-    Every config value can be overridden by an environment variable with the same name in uppercase and a REFLEX_ prefix.
-    For example, `db_url` can be overridden by setting the `REFLEX_DB_URL` environment variable.
+    ## Environment Variable Overrides
+
+    Any config value can be overridden by setting an environment variable with the `REFLEX_`
+    prefix and the parameter name in uppercase:
+
+    ```bash
+    REFLEX_DB_URL="postgresql://user:pass@localhost/db" reflex run
+    REFLEX_FRONTEND_PORT=3001 reflex run
+    ```
+
+    ## Key Configuration Areas
+
+    - **App Settings**: `app_name`, `loglevel`, `telemetry_enabled`
+    - **Server**: `frontend_port`, `backend_port`, `api_url`, `cors_allowed_origins`
+    - **Database**: `db_url`, `async_db_url`, `redis_url`
+    - **Frontend**: `frontend_packages`, `react_strict_mode`
+    - **State Management**: `state_manager_mode`, `state_auto_setters`
+    - **Plugins**: `plugins`, `disable_plugins`
 
-    See the [configuration](https://reflex.dev/docs/getting-started/configuration/) docs for more info.
+    See the [configuration docs](https://reflex.dev/docs/advanced-onboarding/configuration) for complete details on all available options.
     """
 
     # Track whether the app name has already been validated for this Config instance.

reflex/constants/installer.py

@@ -14,7 +14,7 @@ class Bun(SimpleNamespace):
     """Bun constants."""
 
     # The Bun version.
-    VERSION = "1.2.20"
+    VERSION = "1.2.21"
 
     # Min Bun Version
     MIN_VERSION = "1.2.17"
@@ -75,7 +75,7 @@ fetch-retries=0
 
 
 def _determine_react_router_version() -> str:
-    default_version = "7.8.1"
+    default_version = "7.8.2"
     if (version := os.getenv("REACT_ROUTER_VERSION")) and version != default_version:
         from reflex.utils import console
 
@@ -143,11 +143,11 @@ class PackageJson(SimpleNamespace):
         "postcss-import": "16.1.1",
         "@react-router/dev": _react_router_version,
         "@react-router/fs-routes": _react_router_version,
-        "vite": "npm:rolldown-vite@7.1.3",
+        "vite": "npm:rolldown-vite@7.1.5",
     }
     OVERRIDES = {
         # This should always match the `react` version in DEPENDENCIES for recharts compatibility.
         "react-is": _react_version,
         "cookie": "1.0.2",
-        "vite": "npm:rolldown-vite@7.1.3",
+        "vite": "npm:rolldown-vite@7.1.5",
     }

reflex/environment.py

@@ -6,7 +6,6 @@ import concurrent.futures
 import dataclasses
 import enum
 import importlib
-import inspect
 import multiprocessing
 import os
 import platform
@@ -159,7 +158,7 @@ def interpret_plugin_env(value: str, field_name: str) -> Plugin:
         msg = f"Failed to get plugin class {plugin_name!r} from module {import_path!r} for {field_name}: {e}"
         raise EnvironmentVarValueError(msg) from e
 
-    if not inspect.isclass(plugin_class) or not issubclass(plugin_class, Plugin):
+    if not isinstance(plugin_class, type) or not issubclass(plugin_class, Plugin):
         msg = f"Invalid plugin class: {plugin_name!r} for {field_name}. Must be a subclass of Plugin."
         raise EnvironmentVarValueError(msg)
 
@@ -236,7 +235,7 @@ def interpret_env_var_value(
             )
             for i, v in enumerate(value.split(":"))
         ]
-    if inspect.isclass(field_type) and issubclass(field_type, enum.Enum):
+    if isinstance(field_type, type) and issubclass(field_type, enum.Enum):
         return interpret_enum_env(value, field_type, field_name)
 
     msg = f"Invalid type for environment variable {field_name}: {field_type}. This is probably an issue in Reflex."
@@ -640,6 +639,12 @@ class EnvironmentVariables:
     # Enable full logging of debug messages to reflex user directory.
     REFLEX_ENABLE_FULL_LOGGING: EnvVar[bool] = env_var(False)
 
+    # Whether to enable hot module replacement
+    VITE_HMR: EnvVar[bool] = env_var(True)
+
+    # Whether to force a full reload on changes.
+    VITE_FORCE_FULL_RELOAD: EnvVar[bool] = env_var(False)
+
 
 environment = EnvironmentVariables()
 

reflex/istate/data.py

@@ -83,6 +83,11 @@ class HeaderData(_HeaderData):
         )
 
 
+@serializer(to=dict)
+def _serialize_header_data(obj: HeaderData) -> dict:
+    return {k.name: getattr(obj, k.name) for k in dataclasses.fields(obj)}
+
+
 @serializer(to=dict)
 def serialize_frozen_dict_str_str(obj: _FrozenDictStrStr) -> dict:
     """Serialize a _FrozenDictStrStr object to a dict.
@@ -165,6 +170,11 @@ class PageData:
         )
 
 
+@serializer(to=dict)
+def _serialize_page_data(obj: PageData) -> dict:
+    return dataclasses.asdict(obj)
+
+
 @dataclasses.dataclass(frozen=True)
 class SessionData:
     """An object containing session data."""
@@ -190,6 +200,11 @@ class SessionData:
         )
 
 
+@serializer(to=dict)
+def _serialize_session_data(obj: SessionData) -> dict:
+    return dataclasses.asdict(obj)
+
+
 @dataclasses.dataclass(frozen=True)
 class RouterData:
     """An object containing RouterData."""

reflex/plugins/sitemap.py

@@ -5,8 +5,7 @@ from collections.abc import Sequence
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Literal, TypedDict
-from xml.dom import minidom
-from xml.etree.ElementTree import Element, SubElement, tostring
+from xml.etree.ElementTree import Element, SubElement, indent, tostring
 
 from typing_extensions import NotRequired
 
@@ -104,10 +103,8 @@ def generate_xml(links: Sequence[SitemapLink]) -> str:
         if (priority := link.get("priority")) is not None:
             priority_element = SubElement(url, "priority")
             priority_element.text = str(priority)
-
-    rough_string = tostring(urlset, "utf-8")
-    reparsed = minidom.parseString(rough_string)
-    return reparsed.toprettyxml(indent="  ")
+    indent(urlset, "  ")
+    return tostring(urlset, encoding="utf-8", xml_declaration=True).decode("utf-8")
 
 
 def is_route_dynamic(route: str) -> bool:

reflex/reflex.py

@@ -360,7 +360,13 @@ def run(
     default=False,
     help="Run the command without making any changes.",
 )
-def compile(dry: bool):
+@click.option(
+    "--rich/--no-rich",
+    default=True,
+    is_flag=True,
+    help="Whether to use rich progress bars.",
+)
+def compile(dry: bool, rich: bool):
     """Compile the app in the current directory."""
     import time
 
@@ -371,7 +377,7 @@ def compile(dry: bool):
         _init(name=get_config().app_name)
     get_config(reload=True)
     starting_time = time.monotonic()
-    prerequisites.get_compiled_app(dry_run=dry)
+    prerequisites.get_compiled_app(dry_run=dry, use_rich=rich)
     elapsed_time = time.monotonic() - starting_time
     console.success(f"App compiled successfully in {elapsed_time:.3f} seconds.")
 

reflex/state.py

@@ -225,8 +225,20 @@ class EventHandlerSetVar(EventHandler):
             EventHandlerValueError: If the given Var name is not a str
             NotImplementedError: If the setter for the given Var is async
         """
+        from reflex.config import get_config
         from reflex.utils.exceptions import EventHandlerValueError
 
+        config = get_config()
+        if config.state_auto_setters is None:
+            console.deprecate(
+                feature_name="state_auto_setters defaulting to True",
+                reason="The default value will be changed to False in a future release. Set state_auto_setters explicitly or define setters explicitly. "
+                f"Used {self.state_cls.__name__}.setvar without defining it.",
+                deprecation_version="0.8.9",
+                removal_version="0.9.0",
+                dedupe=True,
+            )
+
         if args:
             if not isinstance(args[0], str):
                 msg = f"Var name must be passed as a string, got {args[0]!r}"
@@ -1036,7 +1048,7 @@ class BaseState(EvenMoreBasicBaseState):
             )
             raise VarTypeError(msg)
         cls._set_var(name, prop)
-        if cls.is_user_defined() and get_config().state_auto_setters:
+        if cls.is_user_defined() and get_config().state_auto_setters is not False:
             cls._create_setter(name, prop)
         cls._set_default_value(name, prop)
 
@@ -1096,11 +1108,14 @@ class BaseState(EvenMoreBasicBaseState):
         setattr(cls, name, prop)
 
     @classmethod
-    def _create_event_handler(cls, fn: Any):
+    def _create_event_handler(
+        cls, fn: Any, event_handler_cls: type[EventHandler] = EventHandler
+    ):
         """Create an event handler for the given function.
 
         Args:
             fn: The function to create an event handler for.
+            event_handler_cls: The event handler class to use.
 
         Returns:
             The event handler.
@@ -1108,7 +1123,7 @@ class BaseState(EvenMoreBasicBaseState):
         # Check if function has stored event_actions from decorator
         event_actions = getattr(fn, "_rx_event_actions", {})
 
-        return EventHandler(
+        return event_handler_cls(
             fn=fn, state_full_name=cls.get_full_name(), event_actions=event_actions
         )
 
@@ -1125,9 +1140,34 @@ class BaseState(EvenMoreBasicBaseState):
             name: The name of the var.
             prop: The var to create a setter for.
         """
+        from reflex.config import get_config
+
+        config = get_config()
+        _create_event_handler_kwargs = {}
+
+        if config.state_auto_setters is None:
+
+            class EventHandlerDeprecatedSetter(EventHandler):
+                def __call__(self, *args, **kwargs):
+                    console.deprecate(
+                        feature_name="state_auto_setters defaulting to True",
+                        reason="The default value will be changed to False in a future release. Set state_auto_setters explicitly or define setters explicitly. "
+                        f"Used {setter_name} in {cls.__name__} without defining it.",
+                        deprecation_version="0.8.9",
+                        removal_version="0.9.0",
+                        dedupe=True,
+                    )
+                    return super().__call__(*args, **kwargs)
+
+            _create_event_handler_kwargs["event_handler_cls"] = (
+                EventHandlerDeprecatedSetter
+            )
+
         setter_name = Var._get_setter_name_for_name(name)
         if setter_name not in cls.__dict__:
-            event_handler = cls._create_event_handler(prop._get_setter(name))
+            event_handler = cls._create_event_handler(
+                prop._get_setter(name), **_create_event_handler_kwargs
+            )
             cls.event_handlers[setter_name] = event_handler
             setattr(cls, setter_name, event_handler)
 
@@ -1810,7 +1850,7 @@ class BaseState(EvenMoreBasicBaseState):
                 hinted_args = value_inside_optional(hinted_args)
             if (
                 isinstance(value, dict)
-                and inspect.isclass(hinted_args)
+                and isinstance(hinted_args, type)
                 and not types.is_generic_alias(hinted_args)  # py3.10
             ):
                 if issubclass(hinted_args, Model):
@@ -2341,7 +2381,7 @@ def _serialize_type(type_: Any) -> str:
     Returns:
         The serialized type.
     """
-    if not inspect.isclass(type_):
+    if not isinstance(type_, type):
         return f"{type_}"
     return f"{type_.__module__}.{type_.__qualname__}"
 

reflex/testing.py

@@ -472,7 +472,7 @@ class AppHarness:
         Returns:
             The rendered app global code.
         """
-        if not inspect.isclass(value) and not inspect.isfunction(value):
+        if not isinstance(value, type) and not inspect.isfunction(value):
             return f"{key} = {value!r}"
         return inspect.getsource(value)
 

reflex/utils/console.py

@@ -7,12 +7,13 @@ import datetime
 import inspect
 import os
 import shutil
+import sys
 import time
 from pathlib import Path
 from types import FrameType
 
 from rich.console import Console
-from rich.progress import MofNCompleteColumn, Progress, TimeElapsedColumn
+from rich.progress import MofNCompleteColumn, Progress, TaskID, TimeElapsedColumn
 from rich.prompt import Prompt
 
 from reflex.constants import LogLevel
@@ -244,23 +245,38 @@ def warn(msg: str, *, dedupe: bool = False, **kwargs):
         print_to_log_file(f"[orange1]Warning: {msg}[/orange1]", **kwargs)
 
 
-def _get_first_non_framework_frame() -> FrameType | None:
+@once
+def _exclude_paths_from_frame_info() -> list[Path]:
+    import importlib.util
+
     import click
+    import granian
+    import socketio
     import typing_extensions
 
     import reflex as rx
 
     # Exclude utility modules that should never be the source of deprecated reflex usage.
-    exclude_modules = [click, rx, typing_extensions]
+    exclude_modules = [click, rx, typing_extensions, socketio, granian]
+    modules_paths = [file for m in exclude_modules if (file := m.__file__)] + [
+        spec.origin
+        for m in [*sys.builtin_module_names, *sys.stdlib_module_names]
+        if (spec := importlib.util.find_spec(m)) and spec.origin
+    ]
     exclude_roots = [
         p.parent.resolve() if (p := Path(file)).name == "__init__.py" else p.resolve()
-        for m in exclude_modules
-        if (file := m.__file__)
+        for file in modules_paths
     ]
     # Specifically exclude the reflex cli module.
     if reflex_bin := shutil.which(b"reflex"):
         exclude_roots.append(Path(reflex_bin.decode()))
 
+    return exclude_roots
+
+
+def _get_first_non_framework_frame() -> FrameType | None:
+    exclude_roots = _exclude_paths_from_frame_info()
+
     frame = inspect.currentframe()
     while frame := frame and frame.f_back:
         frame_path = Path(inspect.getfile(frame)).resolve()
@@ -297,13 +313,13 @@ def deprecate(
         filename = Path(origin_frame.f_code.co_filename)
         if filename.is_relative_to(Path.cwd()):
             filename = filename.relative_to(Path.cwd())
-        loc = f"{filename}:{origin_frame.f_lineno}"
+        loc = f" ({filename}:{origin_frame.f_lineno})"
         dedupe_key = f"{dedupe_key} {loc}"
 
     if dedupe_key not in _EMITTED_DEPRECATION_WARNINGS:
         msg = (
             f"{feature_name} has been deprecated in version {deprecation_version}. {reason.rstrip('.').lstrip('. ')}. It will be completely "
-            f"removed in {removal_version}. ({loc})"
+            f"removed in {removal_version}.{loc}"
         )
         if _LOG_LEVEL <= LogLevel.WARNING:
             print(f"[yellow]DeprecationWarning: {msg}[/yellow]", **kwargs)
@@ -395,3 +411,47 @@ def timing(msg: str):
         yield
     finally:
         debug(f"[white]\\[timing] {msg}: {time.time() - start:.2f}s[/white]")
+
+
+class PoorProgress:
+    """A poor man's progress bar."""
+
+    def __init__(self):
+        """Initialize the progress bar."""
+        super().__init__()
+        self.tasks = {}
+        self.progress = 0
+        self.total = 0
+
+    def add_task(self, task: str, total: int):
+        """Add a task to the progress bar.
+
+        Args:
+            task: The task name.
+            total: The total number of steps for the task.
+
+        Returns:
+            The task ID.
+        """
+        self.total += total
+        task_id = TaskID(len(self.tasks))
+        self.tasks[task_id] = {"total": total, "current": 0}
+        return task_id
+
+    def advance(self, task: TaskID, advance: int = 1):
+        """Advance the progress of a task.
+
+        Args:
+            task: The task ID.
+            advance: The number of steps to advance.
+        """
+        if task in self.tasks:
+            self.tasks[task]["current"] += advance
+            self.progress += advance
+            _console.print(f"Progress: {self.progress}/{self.total}")
+
+    def start(self):
+        """Start the progress bar."""
+
+    def stop(self):
+        """Stop the progress bar."""

reflex/utils/frontend_skeleton.py

@@ -10,6 +10,7 @@ import click
 from reflex import constants
 from reflex.compiler import templates
 from reflex.config import Config, get_config
+from reflex.environment import environment
 from reflex.utils import console, path_ops
 from reflex.utils.prerequisites import get_project_hash, get_web_dir
 from reflex.utils.registry import get_npm_registry
@@ -192,7 +193,11 @@ def _compile_vite_config(config: Config):
     base = "/"
     if frontend_path := config.frontend_path.strip("/"):
         base += frontend_path + "/"
-    return templates.vite_config_template(base=base)
+    return templates.vite_config_template(
+        base=base,
+        hmr=environment.VITE_HMR.get(),
+        force_full_reload=environment.VITE_FORCE_FULL_RELOAD.get(),
+    )
 
 
 def initialize_vite_config():

reflex/utils/imports.py

@@ -135,7 +135,7 @@ class ImportVar:
         if self.alias:
             return (
                 self.alias
-                if self.is_default
+                if self.is_default and self.tag != "*"
                 else (self.tag + " as " + self.alias if self.tag else self.alias)
             )
         return self.tag or ""

reflex/utils/prerequisites.py

@@ -248,6 +248,7 @@ def get_compiled_app(
     prerender_routes: bool = False,
     dry_run: bool = False,
     check_if_schema_up_to_date: bool = False,
+    use_rich: bool = True,
 ) -> ModuleType:
     """Get the app module based on the default config after first compiling it.
 
@@ -256,6 +257,7 @@ def get_compiled_app(
         prerender_routes: Whether to prerender routes.
         dry_run: If True, do not write the compiled app to disk.
         check_if_schema_up_to_date: If True, check if the schema is up to date.
+        use_rich: Whether to use rich progress bars.
 
     Returns:
         The compiled app based on the default config.
@@ -263,7 +265,7 @@ def get_compiled_app(
     app, app_module = get_and_validate_app(
         reload=reload, check_if_schema_up_to_date=check_if_schema_up_to_date
     )
-    app._compile(prerender_routes=prerender_routes, dry_run=dry_run)
+    app._compile(prerender_routes=prerender_routes, dry_run=dry_run, use_rich=use_rich)
     return app_module
 
 

reflex/utils/pyi_generator.py

@@ -547,7 +547,7 @@ def _generate_component_create_functiondef(
     kwargs.extend(prop_kwargs)
 
     def figure_out_return_type(annotation: Any):
-        if inspect.isclass(annotation) and issubclass(annotation, inspect._empty):
+        if isinstance(annotation, type) and issubclass(annotation, inspect._empty):
             return ast.Name(id="EventType[Any]")
 
         if not isinstance(annotation, str) and get_origin(annotation) is tuple:
@@ -1181,7 +1181,7 @@ class PyiGenerator:
         class_names = {
             name: obj
             for name, obj in vars(module).items()
-            if inspect.isclass(obj)
+            if isinstance(obj, type)
             and (
                 rx_types.safe_issubclass(obj, Component)
                 or rx_types.safe_issubclass(obj, SimpleNamespace)

reflex/utils/serializers.py

@@ -187,7 +187,7 @@ def get_serializer(type_: type) -> Serializer | None:
 
     # If the type is not registered, check if it is a subclass of a registered type.
     for registered_type, serializer in reversed(SERIALIZERS.items()):
-        if types._issubclass(type_, registered_type):
+        if issubclass(type_, registered_type):
             return serializer
 
     # If there is no serializer, return None.
@@ -211,7 +211,7 @@ def get_serializer_type(type_: type) -> type | None:
 
     # If the type is not registered, check if it is a subclass of a registered type.
     for registered_type, serializer in reversed(SERIALIZER_TYPES.items()):
-        if types._issubclass(type_, registered_type):
+        if issubclass(type_, registered_type):
             return serializer
 
     # If there is no serializer, return None.
@@ -244,11 +244,11 @@ def can_serialize(type_: type, into_type: type | None = None) -> bool:
     Returns:
         Whether there is a serializer for the type.
     """
-    return has_serializer(type_, into_type) or (
+    return (
         isinstance(type_, type)
         and dataclasses.is_dataclass(type_)
         and (into_type is None or into_type is dict)
-    )
+    ) or has_serializer(type_, into_type)
 
 
 @serializer(to=str)