reflex 0.8.0a6__py3-none-any.whl → 0.8.1a1__py3-none-any.whl

reflex/environment.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import concurrent.futures
 import dataclasses
 import enum
+import importlib
 import inspect
 import multiprocessing
 import os
@@ -24,6 +25,7 @@ from typing import (
 )
 
 from reflex import constants
+from reflex.plugins import Plugin
 from reflex.utils.exceptions import EnvironmentVarValueError
 from reflex.utils.types import GenericType, is_union, value_inside_optional
 
@@ -126,6 +128,48 @@ def interpret_path_env(value: str, field_name: str) -> Path:
     return Path(value)
 
 
+def interpret_plugin_env(value: str, field_name: str) -> Plugin:
+    """Interpret a plugin environment variable value.
+
+    Args:
+        value: The environment variable value.
+        field_name: The field name.
+
+    Returns:
+        The interpreted value.
+
+    Raises:
+        EnvironmentVarValueError: If the value is invalid.
+    """
+    if "." not in value:
+        msg = f"Invalid plugin value: {value!r} for {field_name}. Plugin name must be in the format 'package.module.PluginName'."
+        raise EnvironmentVarValueError(msg)
+
+    import_path, plugin_name = value.rsplit(".", 1)
+
+    try:
+        module = importlib.import_module(import_path)
+    except ImportError as e:
+        msg = f"Failed to import module {import_path!r} for {field_name}: {e}"
+        raise EnvironmentVarValueError(msg) from e
+
+    try:
+        plugin_class = getattr(module, plugin_name, None)
+    except Exception as e:
+        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):
+        msg = f"Invalid plugin class: {plugin_name!r} for {field_name}. Must be a subclass of Plugin."
+        raise EnvironmentVarValueError(msg)
+
+    try:
+        return plugin_class()
+    except Exception as e:
+        msg = f"Failed to instantiate plugin {plugin_name!r} for {field_name}: {e}"
+        raise EnvironmentVarValueError(msg) from e
+
+
 def interpret_enum_env(value: str, field_type: GenericType, field_name: str) -> Any:
     """Interpret an enum environment variable value.
 
@@ -181,6 +225,8 @@ def interpret_env_var_value(
         return interpret_path_env(value, field_name)
     if field_type is ExistingPath:
         return interpret_existing_path_env(value, field_name)
+    if field_type is Plugin:
+        return interpret_plugin_env(value, field_name)
     if get_origin(field_type) is list:
         return [
             interpret_env_var_value(
@@ -606,3 +652,73 @@ class EnvironmentVariables:
 
 
 environment = EnvironmentVariables()
+
+try:
+    from dotenv import load_dotenv
+except ImportError:
+    load_dotenv = None
+
+
+def _paths_from_env_files(env_files: str) -> list[Path]:
+    """Convert a string of paths separated by os.pathsep into a list of Path objects.
+
+    Args:
+        env_files: The string of paths.
+
+    Returns:
+        A list of Path objects.
+    """
+    # load env files in reverse order
+    return list(
+        reversed(
+            [
+                Path(path)
+                for path_element in env_files.split(os.pathsep)
+                if (path := path_element.strip())
+            ]
+        )
+    )
+
+
+def _load_dotenv_from_files(files: list[Path]):
+    """Load environment variables from a list of files.
+
+    Args:
+        files: A list of Path objects representing the environment variable files.
+    """
+    from reflex.utils import console
+
+    if not files:
+        return
+
+    if load_dotenv is None:
+        console.error(
+            """The `python-dotenv` package is required to load environment variables from a file. Run `pip install "python-dotenv>=1.1.0"`."""
+        )
+        return
+
+    for env_file in files:
+        if env_file.exists():
+            load_dotenv(env_file, override=True)
+
+
+def _paths_from_environment() -> list[Path]:
+    """Get the paths from the REFLEX_ENV_FILE environment variable.
+
+    Returns:
+        A list of Path objects.
+    """
+    env_files = os.environ.get("REFLEX_ENV_FILE")
+    if not env_files:
+        return []
+
+    return _paths_from_env_files(env_files)
+
+
+def _load_dotenv_from_env():
+    """Load environment variables from paths specified in REFLEX_ENV_FILE."""
+    _load_dotenv_from_files(_paths_from_environment())
+
+
+# Load the env files at import time if they are set in the ENV_FILE environment variable.
+_load_dotenv_from_env()

reflex/event.py

@@ -570,7 +570,7 @@ class JavascriptHTMLInputElement:
 class JavascriptInputEvent:
     """Interface for a Javascript InputEvent https://developer.mozilla.org/en-US/docs/Web/API/InputEvent."""
 
-    target: JavascriptHTMLInputElement = JavascriptHTMLInputElement()  # noqa: RUF009
+    target: JavascriptHTMLInputElement = JavascriptHTMLInputElement()
 
 
 @dataclasses.dataclass(
@@ -1025,6 +1025,22 @@ def set_focus(ref: str) -> EventSpec:
     )
 
 
+def blur_focus(ref: str) -> EventSpec:
+    """Blur focus of specified ref.
+
+    Args:
+        ref: The ref.
+
+    Returns:
+        An event to blur focus on the ref
+    """
+    return server_side(
+        "_blur_focus",
+        get_fn_signature(blur_focus),
+        ref=LiteralVar.create(format.format_ref(ref)),
+    )
+
+
 def scroll_to(elem_id: str, align_to_top: bool | Var[bool] = True) -> EventSpec:
     """Select the id of a html element for scrolling into view.
 
@@ -2293,6 +2309,7 @@ class EventNamespace:
     back = staticmethod(back)
     window_alert = staticmethod(window_alert)
     set_focus = staticmethod(set_focus)
+    blur_focus = staticmethod(blur_focus)
     scroll_to = staticmethod(scroll_to)
     set_value = staticmethod(set_value)
     remove_cookie = staticmethod(remove_cookie)

reflex/istate/data.py

@@ -2,9 +2,11 @@
 
 import dataclasses
 from collections.abc import Mapping
+from typing import TYPE_CHECKING
+from urllib.parse import _NetlocResultMixinStr, urlsplit
 
 from reflex import constants
-from reflex.utils import format
+from reflex.utils import console, format
 from reflex.utils.serializers import serializer
 
 
@@ -45,36 +47,40 @@ class _HeaderData:
     )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+_HEADER_DATA_FIELDS = frozenset(
+    [field.name for field in dataclasses.fields(_HeaderData)]
+)
+
+
+@dataclasses.dataclass(frozen=True)
 class HeaderData(_HeaderData):
     """An object containing headers data."""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the HeaderData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "HeaderData":
+        """Create a HeaderData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A HeaderData object initialized with the provided router_data.
         """
-        super().__init__()
-        if router_data:
-            fields_names = [f.name for f in dataclasses.fields(self)]
-            for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items():
-                snake_case_key = format.to_snake_case(k)
-                if snake_case_key in fields_names:
-                    object.__setattr__(self, snake_case_key, v)
-            object.__setattr__(
-                self,
-                "raw_headers",
-                _FrozenDictStrStr(
-                    **{
-                        k: v
-                        for k, v in router_data.get(
-                            constants.RouteVar.HEADERS, {}
-                        ).items()
-                        if v
-                    }
-                ),
-            )
+        return cls(
+            **{
+                snake_case_key: v
+                for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                if v
+                and (snake_case_key := format.to_snake_case(k)) in _HEADER_DATA_FIELDS
+            },
+            raw_headers=_FrozenDictStrStr(
+                **{
+                    k: v
+                    for k, v in router_data.get(constants.RouteVar.HEADERS, {}).items()
+                    if v
+                }
+            ),
+        )
 
 
 @serializer(to=dict)
@@ -90,6 +96,35 @@ def serialize_frozen_dict_str_str(obj: _FrozenDictStrStr) -> dict:
     return dict(obj._data)
 
 
+class ReflexURL(str, _NetlocResultMixinStr):
+    """A class representing a URL split result."""
+
+    if TYPE_CHECKING:
+        scheme: str
+        netloc: str
+        path: str
+        query: str
+        fragment: str
+
+    def __new__(cls, url: str):
+        """Create a new ReflexURL instance.
+
+        Args:
+            url: the URL to split.
+
+        Returns:
+            A new ReflexURL instance.
+        """
+        (scheme, netloc, path, query, fragment) = urlsplit(url)
+        obj = super().__new__(cls, url)
+        object.__setattr__(obj, "scheme", scheme)
+        object.__setattr__(obj, "netloc", netloc)
+        object.__setattr__(obj, "path", path)
+        object.__setattr__(obj, "query", query)
+        object.__setattr__(obj, "fragment", fragment)
+        return obj
+
+
 @dataclasses.dataclass(frozen=True)
 class PageData:
     """An object containing page data."""
@@ -101,39 +136,30 @@ class PageData:
     full_raw_path: str = ""
     params: dict = dataclasses.field(default_factory=dict)
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the PageData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "PageData":
+        """Create a PageData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A PageData object initialized with the provided router_data.
         """
-        if router_data:
-            object.__setattr__(
-                self,
-                "host",
-                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", ""),
-            )
-            object.__setattr__(
-                self, "path", router_data.get(constants.RouteVar.PATH, "")
-            )
-            object.__setattr__(
-                self, "raw_path", router_data.get(constants.RouteVar.ORIGIN, "")
-            )
-            object.__setattr__(self, "full_path", f"{self.host}{self.path}")
-            object.__setattr__(self, "full_raw_path", f"{self.host}{self.raw_path}")
-            object.__setattr__(
-                self, "params", router_data.get(constants.RouteVar.QUERY, {})
-            )
-        else:
-            object.__setattr__(self, "host", "")
-            object.__setattr__(self, "path", "")
-            object.__setattr__(self, "raw_path", "")
-            object.__setattr__(self, "full_path", "")
-            object.__setattr__(self, "full_raw_path", "")
-            object.__setattr__(self, "params", {})
+        host = router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+        path = router_data.get(constants.RouteVar.PATH, "")
+        raw_path = router_data.get(constants.RouteVar.ORIGIN, "")
+        return cls(
+            host=host,
+            path=path,
+            raw_path=raw_path,
+            full_path=f"{host}{path}",
+            full_raw_path=f"{host}{raw_path}",
+            params=router_data.get(constants.RouteVar.QUERY, {}),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class SessionData:
     """An object containing session data."""
 
@@ -141,37 +167,84 @@ class SessionData:
     client_ip: str = ""
     session_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the SessionData object based on router_data.
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "SessionData":
+        """Create a SessionData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A SessionData object initialized with the provided router_data.
         """
-        if router_data:
-            client_token = router_data.get(constants.RouteVar.CLIENT_TOKEN, "")
-            client_ip = router_data.get(constants.RouteVar.CLIENT_IP, "")
-            session_id = router_data.get(constants.RouteVar.SESSION_ID, "")
-        else:
-            client_token = client_ip = session_id = ""
-        object.__setattr__(self, "client_token", client_token)
-        object.__setattr__(self, "client_ip", client_ip)
-        object.__setattr__(self, "session_id", session_id)
+        return cls(
+            client_token=router_data.get(constants.RouteVar.CLIENT_TOKEN, ""),
+            client_ip=router_data.get(constants.RouteVar.CLIENT_IP, ""),
+            session_id=router_data.get(constants.RouteVar.SESSION_ID, ""),
+        )
 
 
-@dataclasses.dataclass(frozen=True, init=False)
+@dataclasses.dataclass(frozen=True)
 class RouterData:
     """An object containing RouterData."""
 
     session: SessionData = dataclasses.field(default_factory=SessionData)
     headers: HeaderData = dataclasses.field(default_factory=HeaderData)
-    page: PageData = dataclasses.field(default_factory=PageData)
+    _page: PageData = dataclasses.field(default_factory=PageData)
+    url: ReflexURL = dataclasses.field(default=ReflexURL(""))
+    route_id: str = ""
 
-    def __init__(self, router_data: dict | None = None):
-        """Initialize the RouterData object.
+    @property
+    def page(self) -> PageData:
+        """Get the page data.
+
+        Returns:
+            The PageData object.
+        """
+        console.deprecate(
+            "RouterData.page",
+            "Use RouterData.url instead",
+            deprecation_version="0.8.1",
+            removal_version="0.9.0",
+        )
+        return self._page
+
+    @classmethod
+    def from_router_data(cls, router_data: dict) -> "RouterData":
+        """Create a RouterData object from the given router_data.
 
         Args:
             router_data: the router_data dict.
+
+        Returns:
+            A RouterData object initialized with the provided router_data.
         """
-        object.__setattr__(self, "session", SessionData(router_data))
-        object.__setattr__(self, "headers", HeaderData(router_data))
-        object.__setattr__(self, "page", PageData(router_data))
+        return cls(
+            session=SessionData.from_router_data(router_data),
+            headers=HeaderData.from_router_data(router_data),
+            _page=PageData.from_router_data(router_data),
+            url=ReflexURL(
+                router_data.get(constants.RouteVar.HEADERS, {}).get("origin", "")
+                + router_data.get(constants.RouteVar.ORIGIN, "")
+            ),
+            route_id=router_data.get(constants.RouteVar.PATH, ""),
+        )
+
+
+@serializer(to=dict)
+def serialize_router_data(obj: RouterData) -> dict:
+    """Serialize a RouterData object to a dict.
+
+    Args:
+        obj: the RouterData object.
+
+    Returns:
+        A dict representation of the RouterData object.
+    """
+    return {
+        "session": obj.session,
+        "headers": obj.headers,
+        "page": obj._page,
+        "url": obj.url,
+        "route_id": obj.route_id,
+    }

reflex/plugins/tailwind_v4.py

@@ -17,7 +17,7 @@ class Constants(SimpleNamespace):
     """Tailwind constants."""
 
     # The Tailwindcss version
-    VERSION = "tailwindcss@4.1.10"
+    VERSION = "tailwindcss@4.1.11"
     # The Tailwind config.
     CONFIG = "tailwind.config.js"
     # Default Tailwind content paths
@@ -156,7 +156,7 @@ class TailwindV4Plugin(TailwindPlugin):
         return [
             *super().get_frontend_development_dependencies(**context),
             Constants.VERSION,
-            "@tailwindcss/postcss@4.1.10",
+            "@tailwindcss/postcss@4.1.11",
         ]
 
     def pre_compile(self, **context):

reflex/state.py

@@ -1204,7 +1204,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         def argsingle_factory(param: str):
             def inner_func(self: BaseState) -> str:
-                return self.router.page.params.get(param, "")
+                return self.router._page.params.get(param, "")
 
             inner_func.__name__ = param
 
@@ -1212,7 +1212,7 @@ class BaseState(EvenMoreBasicBaseState):
 
         def arglist_factory(param: str):
             def inner_func(self: BaseState) -> list[str]:
-                return self.router.page.params.get(param, [])
+                return self.router._page.params.get(param, [])
 
             inner_func.__name__ = param
 
@@ -2466,7 +2466,7 @@ class OnLoadInternalState(State):
         """
         # Do not app._compile()!  It should be already compiled by now.
         load_events = prerequisites.get_and_validate_app().app.get_load_events(
-            self.router.page.path
+            self.router._page.path
         )
         if not load_events:
             self.is_hydrated = True

reflex/utils/exec.py

@@ -519,9 +519,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
 
     from granian.constants import Interfaces
     from granian.log import LogLevels
-    from granian.server import MPServer as Granian
+    from granian.server import Server as Granian
 
-    Granian(
+    from reflex.environment import _paths_from_environment
+
+    granian_app = Granian(
         target=get_app_instance_from_file(),
         factory=True,
         address=host,
@@ -533,8 +535,11 @@ def run_granian_backend(host: str, port: int, loglevel: LogLevel):
         reload_ignore_worker_failure=True,
         reload_ignore_patterns=HOTRELOAD_IGNORE_PATTERNS,
         reload_tick=100,
+        env_files=_paths_from_environment() or None,
         workers_kill_timeout=2,
-    ).serve()
+    )
+
+    granian_app.serve()
 
 
 def run_backend_prod(
@@ -568,15 +573,37 @@ def run_uvicorn_backend_prod(host: str, port: int, loglevel: LogLevel):
         port: The app port
         loglevel: The log level.
     """
+    import os
+    import shlex
+
     from reflex.utils import processes
 
     app_module = get_app_instance()
 
-    command = (
-        ["uvicorn", *("--host", host), *("--port", str(port)), "--factory", app_module]
-        if constants.IS_WINDOWS
-        else ["gunicorn", "--preload", *("--bind", f"{host}:{port}"), f"{app_module}()"]
-    )
+    if constants.IS_WINDOWS:
+        command = [
+            "uvicorn",
+            *("--host", host),
+            *("--port", str(port)),
+            "--factory",
+            app_module,
+        ]
+    else:
+        # Parse GUNICORN_CMD_ARGS for user overrides
+        env_args = []
+        if gunicorn_cmd_args := os.environ.get("GUNICORN_CMD_ARGS", ""):
+            env_args = shlex.split(gunicorn_cmd_args)
+
+        # Our default args, then env args (env args win on conflicts)
+        command = [
+            "gunicorn",
+            "--preload",
+            "--worker-class",
+            "uvicorn.workers.UvicornH11Worker",
+            *("--bind", f"{host}:{port}"),
+            *env_args,
+            f"{app_module}()",
+        ]
 
     command += [
         *("--log-level", loglevel.value),

reflex/utils/lazy_loader.py

@@ -27,6 +27,7 @@ def attach(
     package_name: str,
     submodules: set[str] | None = None,
     submod_attrs: dict[str, list[str]] | None = None,
+    **extra_mappings,
 ):
     """Replaces a package's __getattr__, __dir__, and __all__ attributes using lazy.attach.
     The lazy loader __getattr__ doesn't support tuples as list values. We needed to add
@@ -39,6 +40,7 @@ def attach(
         submodules : List of submodules to attach.
         submod_attrs : Dictionary of submodule -> list of attributes / functions.
                     These attributes are imported as they are used.
+        extra_mappings: Additional mappings to resolve lazily.
 
     Returns:
         __getattr__, __dir__, __all__
@@ -60,9 +62,13 @@ def attach(
         attr: mod for mod, attrs in submod_attrs.items() for attr in attrs
     }
 
-    __all__ = sorted(submodules | attr_to_modules.keys())
+    __all__ = sorted([*(submodules | attr_to_modules.keys()), *(extra_mappings or [])])
 
     def __getattr__(name: str):  # noqa: N807
+        if name in extra_mappings:
+            submod_path, attr = extra_mappings[name].rsplit(".", 1)
+            submod = importlib.import_module(submod_path)
+            return getattr(submod, attr)
         if name in submodules:
             return importlib.import_module(f"{package_name}.{name}")
         if name in attr_to_modules:

reflex/utils/misc.py

@@ -31,14 +31,13 @@ def get_module_path(module_name: str) -> Path | None:
         for i, part in enumerate(parts):
             potential_file = current_path / (part + ".py")
             potential_dir = current_path / part
-            potential_init = current_path / part / "__init__.py"
 
             if potential_file.is_file():
                 # We encountered a file, but we can't continue deeper
                 if i == len(parts) - 1:
                     return potential_file
                 return None  # Can't continue deeper
-            if potential_dir.is_dir() and potential_init.is_file():
+            if potential_dir.is_dir():
                 # It's a package, so we can continue deeper
                 current_path = potential_dir
             else:

reflex/utils/processes.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 import click
+import rich.markup
 from redis.exceptions import RedisError
 from rich.progress import Progress
 
@@ -61,8 +62,16 @@ def is_process_on_port(port: int) -> bool:
     Returns:
         Whether a process is running on the given port.
     """
+    # Test IPv4 localhost (127.0.0.1)
     with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
-        return sock.connect_ex(("127.0.0.1", port)) == 0
+        ipv4_result = sock.connect_ex(("127.0.0.1", port)) == 0
+
+    # Test IPv6 localhost (::1)
+    with closing(socket.socket(socket.AF_INET6, socket.SOCK_STREAM)) as sock:
+        ipv6_result = sock.connect_ex(("::1", port)) == 0
+
+    # Port is in use if either IPv4 or IPv6 is listening
+    return ipv4_result or ipv6_result
 
 
 def change_port(port: int, _type: str) -> int:
@@ -273,7 +282,7 @@ def stream_logs(
             return
         try:
             for line in process.stdout:
-                console.debug(line, end="", progress=progress)
+                console.debug(rich.markup.escape(line), end="", progress=progress)
                 logs.append(line)
                 yield line
         except ValueError: